From a08aa022b4e1fc1acd00c083836de94bf7527906 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 13 Feb 2026 12:49:25 +0100
Subject: [PATCH 001/391] chore(deps): update Native SDK to v0.12.7 (#5098)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 +++---
 gradle/libs.versions.toml | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1b6484983d5..2334bc7169a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,9 +17,9 @@
 
 ### Dependencies
 
-- Bump Native SDK from v0.12.4 to v0.12.6 ([#5071](https://github.com/getsentry/sentry-java/pull/5071))
-  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0126)
-  - [diff](https://github.com/getsentry/sentry-native/compare/0.12.4...0.12.6)
+- Bump Native SDK from v0.12.4 to v0.12.7 ([#5071](https://github.com/getsentry/sentry-java/pull/5071), [#5098](https://github.com/getsentry/sentry-java/pull/5098))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0127)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.12.4...0.12.7)
 
 ### Internal
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 1e8e498c23b..0df43650549 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -149,7 +149,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.12.6" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.12.7" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From ad8da222b26f12907ae85a777fe43aac3c99431c Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Fri, 13 Feb 2026 13:56:57 +0100
Subject: [PATCH 002/391] fix(logs,metrics): Attach user attributes to logs and
 metrics regardless of sendDefaultPii (#5099)

* fix: Attach user attributes to logs and metrics regardless of sendDefaultPii

When a user is explicitly set on the scope, user.id, user.name, and
user.email are now always attached to log and metric attributes, matching
the existing behavior for error events (SentryClient.applyScope).

Fixes #5078

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog: Add entry for user attributes fix in logs/metrics

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../main/java/io/sentry/logger/LoggerApi.java |  4 +-
 .../java/io/sentry/metrics/MetricsApi.java    |  4 +-
 sentry/src/test/java/io/sentry/ScopesTest.kt  | 46 +++++++++++--------
 4 files changed, 29 insertions(+), 26 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2334bc7169a..c34c5b48c73 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@
 - When merging tombstones with Native SDK, use the tombstone message if the Native SDK didn't explicitly provide one. ([#5095](https://github.com/getsentry/sentry-java/pull/5095))
 - Fix thread leak caused by eager creation of `SentryExecutorService` in `SentryOptions` ([#5093](https://github.com/getsentry/sentry-java/pull/5093))
   - There were cases where we created options that ended up unused but we failed to clean those up.
+- Attach user attributes to logs and metrics regardless of `sendDefaultPii` ([#5099](https://github.com/getsentry/sentry-java/pull/5099))
 - No longer log a warning if a logging integration cannot initialize Sentry due to missing DSN ([#5075](https://github.com/getsentry/sentry-java/pull/5075))
   - While this may have been useful to some, it caused lots of confusion.
 - Session Replay: Add `androidx.camera.view.PreviewView` to default `maskedViewClasses` to mask camera previews by default. ([#5097](https://github.com/getsentry/sentry-java/pull/5097))
diff --git a/sentry/src/main/java/io/sentry/logger/LoggerApi.java b/sentry/src/main/java/io/sentry/logger/LoggerApi.java
index 4b047a26e3d..37a485df315 100644
--- a/sentry/src/main/java/io/sentry/logger/LoggerApi.java
+++ b/sentry/src/main/java/io/sentry/logger/LoggerApi.java
@@ -243,9 +243,7 @@ private void captureLog(
       setServerName(attributes);
     }
 
-    if (scopes.getOptions().isSendDefaultPii()) {
-      setUser(attributes);
-    }
+    setUser(attributes);
 
     return attributes;
   }
diff --git a/sentry/src/main/java/io/sentry/metrics/MetricsApi.java b/sentry/src/main/java/io/sentry/metrics/MetricsApi.java
index 08a15100495..fc16d60e0ec 100644
--- a/sentry/src/main/java/io/sentry/metrics/MetricsApi.java
+++ b/sentry/src/main/java/io/sentry/metrics/MetricsApi.java
@@ -230,9 +230,7 @@ private void captureMetrics(
       setServerName(attributes);
     }
 
-    if (scopes.getOptions().isSendDefaultPii()) {
-      setUser(attributes);
-    }
+    setUser(attributes);
 
     return attributes;
   }
diff --git a/sentry/src/test/java/io/sentry/ScopesTest.kt b/sentry/src/test/java/io/sentry/ScopesTest.kt
index 60ef92e893d..73a14b38e71 100644
--- a/sentry/src/test/java/io/sentry/ScopesTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopesTest.kt
@@ -2953,7 +2953,7 @@ class ScopesTest {
   }
 
   @Test
-  fun `does not add user fields to log attributes by default`() {
+  fun `adds user fields to log attributes even if sendDefaultPii is false`() {
     val (sut, mockClient) =
       getEnabledScopes {
         it.logs.isEnabled = true
@@ -2975,9 +2975,17 @@ class ScopesTest {
         check {
           assertEquals("log message", it.body)
 
-          assertNull(it.attributes?.get("user.id"))
-          assertNull(it.attributes?.get("user.name"))
-          assertNull(it.attributes?.get("user.email"))
+          val userId = it.attributes?.get("user.id")!!
+          assertEquals("usrid", userId.value)
+          assertEquals("string", userId.type)
+
+          val userName = it.attributes?.get("user.name")!!
+          assertEquals("usrname", userName.value)
+          assertEquals("string", userName.type)
+
+          val userEmail = it.attributes?.get("user.email")!!
+          assertEquals("user@sentry.io", userEmail.value)
+          assertEquals("string", userEmail.type)
         },
         anyOrNull(),
       )
@@ -2988,7 +2996,6 @@ class ScopesTest {
     val (sut, mockClient) =
       getEnabledScopes {
         it.logs.isEnabled = true
-        it.isSendDefaultPii = true
         it.distinctId = "distinctId"
       }
 
@@ -3012,7 +3019,6 @@ class ScopesTest {
     val (sut, mockClient) =
       getEnabledScopes {
         it.logs.isEnabled = true
-        it.isSendDefaultPii = true
         it.distinctId = null
       }
 
@@ -3919,7 +3925,7 @@ class ScopesTest {
   }
 
   @Test
-  fun `does not add user fields to metric attributes by default`() {
+  fun `adds user fields to metric attributes even if sendDefaultPii is false`() {
     val (sut, mockClient) = getEnabledScopes { it.distinctId = "distinctId" }
 
     sut.configureScope { scope ->
@@ -3937,9 +3943,17 @@ class ScopesTest {
         check {
           assertEquals("metric name", it.name)
 
-          assertNull(it.attributes?.get("user.id"))
-          assertNull(it.attributes?.get("user.name"))
-          assertNull(it.attributes?.get("user.email"))
+          val userId = it.attributes?.get("user.id")!!
+          assertEquals("usrid", userId.value)
+          assertEquals("string", userId.type)
+
+          val userName = it.attributes?.get("user.name")!!
+          assertEquals("usrname", userName.value)
+          assertEquals("string", userName.type)
+
+          val userEmail = it.attributes?.get("user.email")!!
+          assertEquals("user@sentry.io", userEmail.value)
+          assertEquals("string", userEmail.type)
         },
         anyOrNull(),
         anyOrNull(),
@@ -3948,11 +3962,7 @@ class ScopesTest {
 
   @Test
   fun `unset user does provide distinct-id as user-id for metrics`() {
-    val (sut, mockClient) =
-      getEnabledScopes {
-        it.isSendDefaultPii = true
-        it.distinctId = "distinctId"
-      }
+    val (sut, mockClient) = getEnabledScopes { it.distinctId = "distinctId" }
 
     sut.metrics().count("metric name")
 
@@ -3972,11 +3982,7 @@ class ScopesTest {
 
   @Test
   fun `unset user does provide null user-id when distinct-id is missing for metrics`() {
-    val (sut, mockClient) =
-      getEnabledScopes {
-        it.isSendDefaultPii = true
-        it.distinctId = null
-      }
+    val (sut, mockClient) = getEnabledScopes { it.distinctId = null }
 
     sut.metrics().count("metric name")
 

From 20d5879bc7b24d8394423a1bce7d5801ab764d79 Mon Sep 17 00:00:00 2001
From: romtsn <4999776+romtsn@users.noreply.github.com>
Date: Wed, 18 Feb 2026 12:32:42 +0000
Subject: [PATCH 003/391] release: 8.33.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c34c5b48c73..b74bc0886e1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.33.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 0cd9576e99b..3faa0216ef2 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.9.0
 
 # Release information
-versionName=8.32.0
+versionName=8.33.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 6ea4329a2cc7a4d9f0b8c620676970e14a4eb24c Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Mon, 23 Feb 2026 11:15:22 +0100
Subject: [PATCH 004/391] move contents of CLAUDE.md into AGENTS.md; force
 Claude to read AGENTS.md and some .cursor/skills (#5103)

---
 AGENTS.md | 153 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 CLAUDE.md | 155 ++----------------------------------------------------
 2 files changed, 156 insertions(+), 152 deletions(-)
 create mode 100644 AGENTS.md

diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000000..5793a5e37a2
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,153 @@
+# AGENTS.md
+
+This file provides guidance to AI coding agents when working with code in this repository.
+
+## STOP — Required Reading (Do This First)
+
+Before doing ANYTHING else (including answering questions), you MUST use the Read tool to load these files:
+1. `.cursor/rules/coding.mdc`
+2. `.cursor/rules/overview_dev.mdc`
+
+Then identify and read any topically relevant `.cursor/rules/*.mdc` files for the area you're working on (e.g., `opentelemetry.mdc` for OTel work, `metrics.mdc` for metrics work). Use the Glob tool on `.cursor/rules/*.mdc` to discover available rule files.
+
+Do NOT skip this step. Do NOT proceed without reading these files first.
+
+## Project Overview
+
+This is the Sentry Java/Android SDK - a comprehensive error monitoring and performance tracking SDK for Java and Android applications. The repository contains multiple modules for different integrations and platforms.
+
+## Build System
+
+The project uses **Gradle** with Kotlin DSL. Key build files:
+- `build.gradle.kts` - Root build configuration
+- `settings.gradle.kts` - Multi-module project structure
+- `buildSrc/` and `build-logic/` - Custom build logic and plugins
+- `Makefile` - High-level build commands
+
+## Essential Commands
+
+### Development Workflow
+```bash
+# Format code and regenerate .api files (REQUIRED before committing)
+./gradlew spotlessApply apiDump
+
+# Run all tests and linter
+./gradlew check
+
+# Build entire project
+./gradlew build
+
+# Create coverage reports
+./gradlew jacocoTestReport koverXmlReportRelease
+
+# Generate documentation
+./gradlew aggregateJavadocs
+```
+
+### Testing
+```bash
+# Run unit tests for a specific file
+./gradlew ':<module>:testDebugUnitTest' --tests="*<file name>*" --info
+
+# Run system tests (requires Python virtual env)
+make systemTest
+
+# Run specific test suites
+./gradlew :sentry-android-core:testDebugUnitTest
+./gradlew :sentry:test
+```
+
+### Code Quality
+```bash
+# Check code formatting
+./gradlew spotlessJavaCheck spotlessKotlinCheck
+
+# Apply code formatting
+./gradlew spotlessApply
+
+# Update API dump files (after API changes)
+./gradlew apiDump
+
+# Dependency updates check
+./gradlew dependencyUpdates -Drevision=release
+```
+
+### Android-Specific Commands
+```bash
+# Assemble Android test APKs
+./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleRelease
+./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleAndroidTest -DtestBuildType=release
+
+# Run critical UI tests
+./scripts/test-ui-critical.sh
+```
+
+## Development Workflow Rules
+
+### Planning and Implementation Process
+1. **First think through the problem**: Read the codebase for relevant files and propose a plan
+2. **Check in before beginning**: Verify the plan before starting implementation
+3. **Use todo tracking**: Work through todo items, marking them as complete as you go
+4. **High-level communication**: Give high-level explanations of changes made, not step-by-step descriptions
+5. **Simplicity first**: Make every task and code change as simple as possible. Avoid massive or complex changes. Impact as little code as possible.
+6. **Format and regenerate**: Once done, format code and regenerate .api files: `./gradlew spotlessApply apiDump`
+7. **Propose commit**: As final step, git stage relevant files and propose (but not execute) a single git commit command
+
+## Module Architecture
+
+The repository is organized into multiple modules:
+
+### Core Modules
+- **`sentry`** - Core Java SDK implementation
+- **`sentry-android-core`** - Core Android SDK implementation
+- **`sentry-android`** - High-level Android SDK
+
+### Integration Modules
+- **Spring Framework**: `sentry-spring*`, `sentry-spring-boot*`
+- **Logging**: `sentry-logback`, `sentry-log4j2`, `sentry-jul`
+- **Web**: `sentry-servlet*`, `sentry-okhttp`, `sentry-apache-http-client-5`
+- **GraphQL**: `sentry-graphql*`, `sentry-apollo*`
+- **Android UI**: `sentry-android-fragment`, `sentry-android-navigation`, `sentry-compose`
+- **Reactive**: `sentry-reactor`, `sentry-ktor-client`
+- **Monitoring**: `sentry-opentelemetry*`, `sentry-quartz`
+
+### Utility Modules
+- **`sentry-test-support`** - Shared test utilities
+- **`sentry-system-test-support`** - System testing infrastructure
+- **`sentry-samples`** - Example applications
+- **`sentry-bom`** - Bill of Materials for dependency management
+
+### Key Architectural Patterns
+- **Multi-platform**: Supports JVM, Android, and Kotlin Multiplatform (Compose modules)
+- **Modular Design**: Each integration is a separate module with minimal dependencies
+- **Options Pattern**: Features are opt-in via `SentryOptions` and similar configuration classes
+- **Transport Layer**: Pluggable transport implementations for different environments
+- **Scope Management**: Thread-safe scope/context management for error tracking
+
+## Development Guidelines
+
+### Code Style
+- **Languages**: Java 8+ and Kotlin
+- **Formatting**: Enforced via Spotless - always run `./gradlew spotlessApply` before committing
+- **API Compatibility**: Binary compatibility is enforced - run `./gradlew apiDump` after API changes
+
+### Testing Requirements
+- Write comprehensive unit tests for new features
+- Android modules require both unit tests and instrumented tests where applicable
+- System tests validate end-to-end functionality with sample applications
+- Coverage reports are generated for both JaCoCo (Java/Android) and Kover (KMP modules)
+
+### Contributing Guidelines
+1. Follow existing code style and language
+2. Do not modify API files (e.g. sentry.api) manually - run `./gradlew apiDump` to regenerate them
+3. Write comprehensive tests
+4. New features must be **opt-in by default** - extend `SentryOptions` or similar Option classes with getters/setters
+5. Consider backwards compatibility
+
+## Useful Resources
+
+- Main SDK documentation: https://develop.sentry.dev/sdk/overview/
+- Internal contributing guide: https://docs.sentry.io/internal/contributing/
+- Git commit message conventions: https://develop.sentry.dev/engineering-practices/commit-messages/
+
+This SDK is production-ready and used by thousands of applications. Changes should be thoroughly tested and maintain backwards compatibility.
diff --git a/CLAUDE.md b/CLAUDE.md
index 9de4130c1a7..9c24f45b02e 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,156 +1,7 @@
 # CLAUDE.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+## STOP — Required Reading (Do This First)
 
-## Project Overview
+Before doing ANYTHING else (including answering questions), you MUST use the Read tool to load [AGENTS.md](AGENTS.md) and follow ALL of its instructions, including reading the required `.cursor/rules/*.mdc` files it references.
 
-This is the Sentry Java/Android SDK - a comprehensive error monitoring and performance tracking SDK for Java and Android applications. The repository contains multiple modules for different integrations and platforms.
-
-## Build System
-
-The project uses **Gradle** with Kotlin DSL. Key build files:
-- `build.gradle.kts` - Root build configuration
-- `settings.gradle.kts` - Multi-module project structure
-- `buildSrc/` and `build-logic/` - Custom build logic and plugins
-- `Makefile` - High-level build commands
-
-## Essential Commands
-
-### Development Workflow
-```bash
-# Format code and regenerate .api files (REQUIRED before committing)
-./gradlew spotlessApply apiDump
-
-# Run all tests and linter
-./gradlew check
-
-# Build entire project
-./gradlew build
-
-# Create coverage reports
-./gradlew jacocoTestReport koverXmlReportRelease
-
-# Generate documentation
-./gradlew aggregateJavadocs
-```
-
-### Testing
-```bash
-# Run unit tests for a specific file
-./gradlew ':<module>:testDebugUnitTest' --tests="*<file name>*" --info
-
-# Run system tests (requires Python virtual env)
-make systemTest
-
-# Run specific test suites
-./gradlew :sentry-android-core:testDebugUnitTest
-./gradlew :sentry:test
-```
-
-### Code Quality
-```bash
-# Check code formatting
-./gradlew spotlessJavaCheck spotlessKotlinCheck
-
-# Apply code formatting
-./gradlew spotlessApply
-
-# Update API dump files (after API changes)
-./gradlew apiDump
-
-# Dependency updates check
-./gradlew dependencyUpdates -Drevision=release
-```
-
-### Android-Specific Commands
-```bash
-# Assemble Android test APKs
-./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleRelease
-./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleAndroidTest -DtestBuildType=release
-
-# Run critical UI tests
-./scripts/test-ui-critical.sh
-```
-
-## Development Workflow Rules
-
-### Planning and Implementation Process
-1. **First think through the problem**: Read the codebase for relevant files and propose a plan
-2. **Check in before beginning**: Verify the plan before starting implementation
-3. **Use todo tracking**: Work through todo items, marking them as complete as you go
-4. **High-level communication**: Give high-level explanations of changes made, not step-by-step descriptions
-5. **Simplicity first**: Make every task and code change as simple as possible. Avoid massive or complex changes. Impact as little code as possible.
-6. **Format and regenerate**: Once done, format code and regenerate .api files: `./gradlew spotlessApply apiDump`
-7. **Propose commit**: As final step, git stage relevant files and propose (but not execute) a single git commit command
-
-## Module Architecture
-
-The repository is organized into multiple modules:
-
-### Core Modules
-- **`sentry`** - Core Java SDK implementation
-- **`sentry-android-core`** - Core Android SDK implementation
-- **`sentry-android`** - High-level Android SDK
-
-### Integration Modules
-- **Spring Framework**: `sentry-spring*`, `sentry-spring-boot*`
-- **Logging**: `sentry-logback`, `sentry-log4j2`, `sentry-jul`
-- **Web**: `sentry-servlet*`, `sentry-okhttp`, `sentry-apache-http-client-5`
-- **GraphQL**: `sentry-graphql*`, `sentry-apollo*`
-- **Android UI**: `sentry-android-fragment`, `sentry-android-navigation`, `sentry-compose`
-- **Reactive**: `sentry-reactor`, `sentry-ktor-client`
-- **Monitoring**: `sentry-opentelemetry*`, `sentry-quartz`
-
-### Utility Modules  
-- **`sentry-test-support`** - Shared test utilities
-- **`sentry-system-test-support`** - System testing infrastructure
-- **`sentry-samples`** - Example applications
-- **`sentry-bom`** - Bill of Materials for dependency management
-
-### Key Architectural Patterns
-- **Multi-platform**: Supports JVM, Android, and Kotlin Multiplatform (Compose modules)
-- **Modular Design**: Each integration is a separate module with minimal dependencies
-- **Options Pattern**: Features are opt-in via `SentryOptions` and similar configuration classes
-- **Transport Layer**: Pluggable transport implementations for different environments
-- **Scope Management**: Thread-safe scope/context management for error tracking
-
-## Development Guidelines
-
-### Code Style
-- **Languages**: Java 8+ and Kotlin
-- **Formatting**: Enforced via Spotless - always run `./gradlew spotlessApply` before committing
-- **API Compatibility**: Binary compatibility is enforced - run `./gradlew apiDump` after API changes
-
-### Testing Requirements
-- Write comprehensive unit tests for new features
-- Android modules require both unit tests and instrumented tests where applicable
-- System tests validate end-to-end functionality with sample applications
-- Coverage reports are generated for both JaCoCo (Java/Android) and Kover (KMP modules)
-
-### Contributing Guidelines
-1. Follow existing code style and language
-2. Do not modify API files (e.g. sentry.api) manually - run `./gradlew apiDump` to regenerate them
-3. Write comprehensive tests
-4. New features must be **opt-in by default** - extend `SentryOptions` or similar Option classes with getters/setters
-5. Consider backwards compatibility
-
-## Domain-Specific Knowledge Areas
-
-For complex SDK functionality, refer to the detailed cursor rules in `.cursor/rules/`:
-
-- **Scopes and Hub Management**: See `.cursor/rules/scopes.mdc` for details on `IScopes`, scope types (global/isolation/current), thread-local storage, forking behavior, and v7→v8 migration patterns
-- **Event Deduplication**: See `.cursor/rules/deduplication.mdc` for `DuplicateEventDetectionEventProcessor` and `enableDeduplication` option
-- **Offline Behavior and Caching**: See `.cursor/rules/offline.mdc` for envelope caching, retry logic, transport behavior, and Android vs JVM differences
-- **OpenTelemetry Integration**: See `.cursor/rules/opentelemetry.mdc` for agent vs agentless modes, span processing, context propagation, and configuration
-- **System Testing (E2E)**: See `.cursor/rules/e2e_tests.mdc` for system test framework, mock server setup, and CI workflows
-
-### Usage Pattern
-When working on these specific areas, read the corresponding cursor rule file first to understand the detailed architecture, then proceed with implementation.
-
-## Useful Resources
-
-- Main SDK documentation: https://develop.sentry.dev/sdk/overview/
-- Internal contributing guide: https://docs.sentry.io/internal/contributing/
-- Git commit message conventions: https://develop.sentry.dev/engineering-practices/commit-messages/
-
-This SDK is production-ready and used by thousands of applications. Changes should be thoroughly tested and maintain backwards compatibility.
\ No newline at end of file
+Do NOT skip this step. Do NOT proceed without reading these files first.

From 70118e980b52b8e8bdf5734b4b6c59db903d74b8 Mon Sep 17 00:00:00 2001
From: kollesnica1337 <159715199+kollesnica1337@users.noreply.github.com>
Date: Tue, 24 Feb 2026 13:29:36 +0300
Subject: [PATCH 005/391] fix(android): unregister
 SystemEventsBroadcastReceiver safely (#5106)

* fix: safe unregister SystemEventsBroadcastReceiver

* Add changelog

* Revert format changes

* Fix code format

* Update Changelog

* Catch exception more broadly

* Remove exception duplicate in logging

---------

Co-authored-by: viyakovlev <viyakovlev@ozon.ru>
Co-authored-by: Markus Hintersteiner <markus.hintersteiner@sentry.io>
---
 CHANGELOG.md                                    |  6 ++++++
 .../SystemEventsBreadcrumbsIntegration.java     | 15 +++++++++++----
 .../SystemEventsBreadcrumbsIntegrationTest.kt   | 17 ++++++++++++++++-
 3 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b74bc0886e1..df25c4b000f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Fix crash when unregistering `SystemEventsBroadcastReceiver` with try-catch block. ([#5106](https://github.com/getsentry/sentry-java/pull/5106))
+
 ## 8.33.0
 
 ### Features
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SystemEventsBreadcrumbsIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/SystemEventsBreadcrumbsIntegration.java
index a5e56fcc3f2..18ff901b0e9 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SystemEventsBreadcrumbsIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SystemEventsBreadcrumbsIntegration.java
@@ -203,13 +203,13 @@ private void scheduleUnregisterReceiver() {
     }
 
     try {
-      options.getExecutorService().submit(() -> unregisterReceiver());
+      options.getExecutorService().submit(() -> unregisterReceiver(options));
     } catch (RejectedExecutionException e) {
-      unregisterReceiver();
+      unregisterReceiver(options);
     }
   }
 
-  private void unregisterReceiver() {
+  private void unregisterReceiver(final @NotNull SentryAndroidOptions options) {
     final @Nullable SystemEventsBroadcastReceiver receiverRef;
     try (final @NotNull ISentryLifecycleToken ignored = receiverLock.acquire()) {
       isStopped = true;
@@ -218,7 +218,14 @@ private void unregisterReceiver() {
     }
 
     if (receiverRef != null) {
-      context.unregisterReceiver(receiverRef);
+      try {
+        context.unregisterReceiver(receiverRef);
+      } catch (Throwable exception) {
+        options
+            .getLogger()
+            .log(
+                SentryLevel.ERROR, exception, "Failed to unregister SystemEventsBroadcastReceiver");
+      }
     }
   }
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SystemEventsBreadcrumbsIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SystemEventsBreadcrumbsIntegrationTest.kt
index fe5e6c775b2..2505b6f7f7d 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SystemEventsBreadcrumbsIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SystemEventsBreadcrumbsIntegrationTest.kt
@@ -52,6 +52,7 @@ class SystemEventsBreadcrumbsIntegrationTest {
     lateinit var shadowActivityManager: ShadowActivityManager
 
     fun getSut(
+      contextForSut: Context = context,
       enableSystemEventBreadcrumbs: Boolean = true,
       enableSystemEventBreadcrumbsExtras: Boolean = false,
       executorService: ISentryExecutorService = ImmediateExecutorService(),
@@ -64,7 +65,7 @@ class SystemEventsBreadcrumbsIntegrationTest {
           this.executorService = executorService
         }
       return SystemEventsBreadcrumbsIntegration(
-        context,
+        contextForSut,
         SystemEventsBreadcrumbsIntegration.getDefaultActions().toTypedArray(),
         handler,
       )
@@ -313,6 +314,20 @@ class SystemEventsBreadcrumbsIntegrationTest {
     assertFalse(fixture.options.isEnableSystemEventBreadcrumbs)
   }
 
+  @Test
+  fun `Do not crash if receiver already unregistered`() {
+    val realContext = ApplicationProvider.getApplicationContext<Context>()
+    val sut = fixture.getSut(realContext)
+
+    sut.register(fixture.scopes, fixture.options)
+
+    realContext.unregisterReceiver(sut.receiver)
+
+    val result = runCatching { sut.onBackground() }
+
+    assertFalse(result.isFailure)
+  }
+
   @Test
   fun `when str has full package, return last string after dot`() {
     val sut = fixture.getSut()

From 2e02ebacc466462fccd7ad87231d8da8539585e6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 25 Feb 2026 10:16:43 +0000
Subject: [PATCH 006/391] build(deps): bump getsentry/craft from 2.21.2 to
 2.21.7 (#5110)

Bumps [getsentry/craft](https://github.com/getsentry/craft) from 2.21.2 to 2.21.7.
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/63d1636bead951f6e034ed62c2a3610965fef010...41defb379de52e5f0e3943944fa5575b22fb9f92)

---
updated-dependencies:
- dependency-name: getsentry/craft
  dependency-version: 2.21.7
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 24a9dd81cbf..0dd2ea4b92c 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@63d1636bead951f6e034ed62c2a3610965fef010 # v2
+        uses: getsentry/craft@41defb379de52e5f0e3943944fa5575b22fb9f92 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From 382d6c1d1af9433d54a637ef01e2588350ee28db Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 25 Feb 2026 11:22:27 +0100
Subject: [PATCH 007/391] build(deps): bump github/codeql-action from 4.32.2 to
 4.32.4 (#5109)

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.32.2 to 4.32.4.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2...89a39a4e59826350b863aa6b6252a07ad50cf83e)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-version: 4.32.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql-analysis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index a49c5a1a0cc..c93a2128524 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # pin@v2
+        uses: github/codeql-action/init@89a39a4e59826350b863aa6b6252a07ad50cf83e # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@45cbd0c69e560cd9e7cd7f8c32362050c9b7ded2 # pin@v2
+        uses: github/codeql-action/analyze@89a39a4e59826350b863aa6b6252a07ad50cf83e # pin@v2

From 0d66c0b0232303de347fad2543d483be0125aab5 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 26 Feb 2026 12:25:12 +0100
Subject: [PATCH 008/391] feat(screenshot): Add screenshot masking using view
 hierarchy (#5077)

* feat(screenshot): Add screenshot masking using view hierarchy

Adds masking support to error screenshots by reusing the Session Replay
masking logic. This allows sensitive content (text, images) to be masked
before attaching screenshots to error events.

- Add SentryMaskingOptions base class for shared masking configuration
- Add SentryScreenshotOptions for screenshot-specific masking settings
- Create MaskRenderer utility for shared mask rendering (used by both
  replay and screenshots)
- Add manifest metadata support for screenshot masking options
- Add snapshot tests with Dropbox Differ library for visual regression
- Update CLAUDE.md with dependency management guidelines

Masking requires the sentry-android-replay module to be present at runtime.
Without it, screenshots are captured without masking.

Refs: getsentry/sentry-java#3286

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* Changelog

* dontwarn about classes we check via reflection at runtime

* pr id

* fix(screenshot): Only warn about missing replay module when masking is configured

The isMaskingEnabled() method was logging a warning before checking if
masking was actually configured. This caused users who never set up
screenshot masking to see spurious warnings on every event.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(screenshot): Remove sensitive view classes when setMaskAllImages(false) is called

setMaskAllImages(true) was adding WebView, VideoView, and ExoPlayer
classes to maskViewClasses, but setMaskAllImages(false) only removed
ImageView. This caused asymmetric toggle behavior where disabling
image masking didn't restore the original state.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(screenshot): Recycle bitmap copy on masking failure to prevent memory leak

When an exception occurred in applyMasking after creating a mutable
copy of the bitmap, the catch block returned the original screenshot
without recycling the copy. This caused bitmap memory to accumulate
until GC runs, potentially causing OOM issues on frequent errors.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix: Resolve merge conflicts with main and integrate trackCustomMasking

Move trackCustomMasking() to SentryMaskingOptions as an abstract method
so it can be called polymorphically from replay view hierarchy code.
SentryReplayOptions provides the real implementation, while
SentryScreenshotOptions provides a no-op. Also adds
CAMERAX_PREVIEW_VIEW_CLASS_NAME to SentryMaskingOptions.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Clean up slop

* fix(test): Implement abstract trackCustomMasking in test stub

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(screenshot): Use peekDecorView instead of getDecorView

peekDecorView returns null if the decor view hasn't been created yet,
avoiding forced creation. This is consistent with the rest of the
codebase (ScreenshotUtils, ViewHierarchyEventProcessor).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor(screenshot): Per-call MaskRenderer, main-thread VH capture, and don't leak unmasked screenshots

- Use per-call MaskRenderer via try-with-resources instead of shared instance
- Remove Closeable from ScreenshotEventProcessor (nothing to clean up)
- Capture view hierarchy on main thread via runOnUiThread + CountDownLatch
- Apply masking on the calling thread (only VH traversal needs main thread)
- Return null on masking failure to avoid sending unmasked screenshots
- Fix setMaskViewContainerClass to not trigger trackCustomMasking

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix tests and remove slop

* clean up

* fix(masking): Remove from opposite set when adding mask/unmask view class

addMaskViewClass now removes from unmaskViewClasses and vice versa,
preventing stale entries from silently blocking masking when
setMaskAllText(false)/setMaskAllImages(false) is called with defaults.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* delegate to super in SentryReplayOptions

* Do not capture screenshot when copy bitmap fails

* fix(screenshot): Recycle bitmaps on all early-return paths to prevent memory leaks

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(screenshot): Log missing replay module warning once in constructor instead of per event

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Move PR id info to AGENTS.md

* refactor: Rename getScreenshotOptions() to getScreenshot() to match getSessionReplay() pattern

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs: Move screenshot masking changelog entry to Unreleased with code snippets

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(screenshot): Avoid crash from uncaught exception in view hierarchy traversal and unnecessary bitmap alloc in MaskRenderer.close()

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: Fix MaskRendererTest after lazy bitmap init guard and simplify test setup

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(screenshot): Wrap runOnUiThread in try-catch to handle destroyed activity race condition

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Bail out early if replay module is not available but masking is enabled for screenshots

* fix(test): Expect no screenshot when masking configured without replay module

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
---
 AGENTS.md                                     |  15 +
 CHANGELOG.md                                  |  22 ++
 CLAUDE.md                                     |   1 -
 gradle/libs.versions.toml                     |   1 +
 .../api/sentry-android-core.api               |   9 +-
 sentry-android-core/build.gradle.kts          |   1 +
 .../core/AndroidOptionsInitializer.java       |   3 +-
 .../android/core/ManifestMetadataReader.java  |  12 +
 .../core/ScreenshotEventProcessor.java        | 146 +++++++-
 .../android/core/SentryAndroidOptions.java    |  18 +
 .../android/core/SentryScreenshotOptions.java |  60 ++++
 .../core/ManifestMetadataReaderTest.kt        |  72 ++++
 .../core/ScreenshotEventProcessorTest.kt      | 280 +++++++++++++--
 .../core/SentryScreenshotOptionsTest.kt       | 113 ++++++
 .../src/test/resources/Tongariro.jpg          | Bin 0 -> 239154 bytes
 .../screenshot_mask_all.png                   | Bin 0 -> 2673 bytes
 .../screenshot_mask_custom_view.png           | Bin 0 -> 14948 bytes
 .../screenshot_mask_images.png                | Bin 0 -> 9353 bytes
 .../screenshot_mask_text.png                  | Bin 0 -> 8428 bytes
 .../screenshot_no_masking.png                 | Bin 0 -> 14845 bytes
 .../sentry-uitest-android/proguard-rules.pro  |   4 +
 .../replay/screenshot/PixelCopyStrategy.kt    |  92 +----
 .../android/replay/util/MaskRenderer.kt       | 118 +++++++
 .../io/sentry/android/replay/util/Views.kt    |  17 +-
 .../viewhierarchy/ComposeViewHierarchyNode.kt |  41 ++-
 .../replay/viewhierarchy/ViewHierarchyNode.kt |  27 +-
 .../android/replay/util/MaskRendererTest.kt   | 326 ++++++++++++++++++
 .../replay/util/TextViewDominantColorTest.kt  |  24 +-
 .../ComposeMaskingOptionsTest.kt              |  12 +-
 .../ContainerMaskingOptionsTest.kt            |  41 ++-
 .../viewhierarchy/MaskingOptionsTest.kt       |  66 +++-
 .../src/main/AndroidManifest.xml              |   8 +-
 sentry/api/sentry.api                         |  43 ++-
 sentry/src/main/java/io/sentry/Scopes.java    |  15 +
 .../java/io/sentry/SentryMaskingOptions.java  | 129 +++++++
 .../java/io/sentry/SentryReplayOptions.java   | 114 +-----
 .../io/sentry/SentryMaskingOptionsTest.kt     | 133 +++++++
 37 files changed, 1668 insertions(+), 295 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/SentryScreenshotOptions.java
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/SentryScreenshotOptionsTest.kt
 create mode 100644 sentry-android-core/src/test/resources/Tongariro.jpg
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_all.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_custom_view.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_images.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_text.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_no_masking.png
 create mode 100644 sentry-android-replay/src/main/java/io/sentry/android/replay/util/MaskRenderer.kt
 create mode 100644 sentry-android-replay/src/test/java/io/sentry/android/replay/util/MaskRendererTest.kt
 create mode 100644 sentry/src/main/java/io/sentry/SentryMaskingOptions.java
 create mode 100644 sentry/src/test/java/io/sentry/SentryMaskingOptionsTest.kt

diff --git a/AGENTS.md b/AGENTS.md
index 5793a5e37a2..fad3dc5a54e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -144,6 +144,21 @@ The repository is organized into multiple modules:
 4. New features must be **opt-in by default** - extend `SentryOptions` or similar Option classes with getters/setters
 5. Consider backwards compatibility
 
+### Getting PR Information
+
+Use `gh pr view` to get PR details from the current branch. This is needed when adding changelog entries, which require the PR number.
+
+```bash
+# Get PR number for current branch
+gh pr view --json number -q '.number'
+
+# Get PR number for a specific branch
+gh pr view <branch-name> --json number -q '.number'
+
+# Get PR URL
+gh pr view --json url -q '.url'
+```
+
 ## Useful Resources
 
 - Main SDK documentation: https://develop.sentry.dev/sdk/overview/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index df25c4b000f..b3de4ffc7e3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,28 @@
 
 ## Unreleased
 
+### Features
+
+- Add screenshot masking support using view hierarchy ([#5077](https://github.com/getsentry/sentry-java/pull/5077))
+  - Masks sensitive content (text, images) in error screenshots using the same view hierarchy approach as Session Replay
+  - Requires the `sentry-android-replay` module to be present at runtime for masking to work
+  - Enable via code:
+    ```kotlin
+    SentryAndroid.init(context) { options ->
+        options.isAttachScreenshot = true
+        options.screenshot.setMaskAllText(true)
+        options.screenshot.setMaskAllImages(true)
+        // Or mask specific view classes
+        options.screenshot.addMaskViewClass("com.example.MyCustomView")
+    }
+    ```
+  - Or via `AndroidManifest.xml`:
+    ```xml
+    <meta-data android:name="io.sentry.attach-screenshot" android:value="true" />
+    <meta-data android:name="io.sentry.screenshot.mask-all-text" android:value="true" />
+    <meta-data android:name="io.sentry.screenshot.mask-all-images" android:value="true" />
+    ```
+
 ### Fixes
 
 - Fix crash when unregistering `SystemEventsBroadcastReceiver` with try-catch block. ([#5106](https://github.com/getsentry/sentry-java/pull/5106))
diff --git a/CLAUDE.md b/CLAUDE.md
index 9c24f45b02e..19507016af4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -3,5 +3,4 @@
 ## STOP — Required Reading (Do This First)
 
 Before doing ANYTHING else (including answering questions), you MUST use the Read tool to load [AGENTS.md](AGENTS.md) and follow ALL of its instructions, including reading the required `.cursor/rules/*.mdc` files it references.
-
 Do NOT skip this step. Do NOT proceed without reading these files first.
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 0df43650549..7e9a7af4840 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -236,3 +236,4 @@ msgpack = { module = "org.msgpack:msgpack-core", version = "0.9.8" }
 okhttp-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version.ref = "okhttp" }
 okio = { module = "com.squareup.okio:okio", version = "1.13.0" }
 roboelectric = { module = "org.robolectric:robolectric", version = "4.14" }
+dropbox-differ = { module = "com.dropbox.differ:differ-jvm", version = "0.3.0" }
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 69b3982af8d..7e64d0bcf80 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -326,7 +326,7 @@ public final class io/sentry/android/core/NetworkBreadcrumbsIntegration : io/sen
 }
 
 public final class io/sentry/android/core/ScreenshotEventProcessor : io/sentry/EventProcessor {
-	public fun <init> (Lio/sentry/android/core/SentryAndroidOptions;Lio/sentry/android/core/BuildInfoProvider;)V
+	public fun <init> (Lio/sentry/android/core/SentryAndroidOptions;Lio/sentry/android/core/BuildInfoProvider;Z)V
 	public fun getOrder ()Ljava/lang/Long;
 	public fun process (Lio/sentry/SentryEvent;Lio/sentry/Hint;)Lio/sentry/SentryEvent;
 	public fun process (Lio/sentry/protocol/SentryTransaction;Lio/sentry/Hint;)Lio/sentry/protocol/SentryTransaction;
@@ -354,6 +354,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun getFrameMetricsCollector ()Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;
 	public fun getNativeSdkName ()Ljava/lang/String;
 	public fun getNdkHandlerStrategy ()I
+	public fun getScreenshot ()Lio/sentry/android/core/SentryScreenshotOptions;
 	public fun getStartupCrashDurationThresholdMillis ()J
 	public fun isAnrEnabled ()Z
 	public fun isAnrReportInDebug ()Z
@@ -450,6 +451,12 @@ public final class io/sentry/android/core/SentryPerformanceProvider {
 	public fun shutdown ()V
 }
 
+public final class io/sentry/android/core/SentryScreenshotOptions : io/sentry/SentryMaskingOptions {
+	public fun <init> ()V
+	public fun setMaskAllImages (Z)V
+	public fun trackCustomMasking ()V
+}
+
 public class io/sentry/android/core/SentryUserFeedbackButton : android/widget/Button {
 	public fun <init> (Landroid/content/Context;)V
 	public fun <init> (Landroid/content/Context;Landroid/util/AttributeSet;)V
diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index 8d5f73fbf44..23dc964d3d6 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -108,6 +108,7 @@ dependencies {
   testImplementation(projects.sentryAndroidReplay)
   testImplementation(projects.sentryCompose)
   testImplementation(projects.sentryAndroidNdk)
+  testImplementation(libs.dropbox.differ)
   testRuntimeOnly(libs.androidx.compose.ui)
   testRuntimeOnly(libs.androidx.fragment.ktx)
   testRuntimeOnly(libs.timber)
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 81ac3b35d6a..5bfebaed922 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -188,7 +188,8 @@ static void initializeIntegrationsAndProcessors(
     options.addEventProcessor(
         new DefaultAndroidEventProcessor(context, buildInfoProvider, options));
     options.addEventProcessor(new PerformanceAndroidEventProcessor(options, activityFramesTracker));
-    options.addEventProcessor(new ScreenshotEventProcessor(options, buildInfoProvider));
+    options.addEventProcessor(
+        new ScreenshotEventProcessor(options, buildInfoProvider, isReplayAvailable));
     options.addEventProcessor(new ViewHierarchyEventProcessor(options));
     options.addEventProcessor(
         new ApplicationExitInfoEventProcessor(context, options, buildInfoProvider));
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 17d75b39c74..66587925404 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -170,6 +170,10 @@ final class ManifestMetadataReader {
 
   static final String SPOTLIGHT_CONNECTION_URL = "io.sentry.spotlight.url";
 
+  static final String SCREENSHOT_MASK_ALL_TEXT = "io.sentry.screenshot.mask-all-text";
+
+  static final String SCREENSHOT_MASK_ALL_IMAGES = "io.sentry.screenshot.mask-all-images";
+
   /** ManifestMetadataReader ctor */
   private ManifestMetadataReader() {}
 
@@ -659,6 +663,14 @@ static void applyMetadata(
         if (spotlightUrl != null) {
           options.setSpotlightConnectionUrl(spotlightUrl);
         }
+
+        // Screenshot masking options (default to false for backwards compatibility)
+        options
+            .getScreenshot()
+            .setMaskAllText(readBool(metadata, logger, SCREENSHOT_MASK_ALL_TEXT, false));
+        options
+            .getScreenshot()
+            .setMaskAllImages(readBool(metadata, logger, SCREENSHOT_MASK_ALL_IMAGES, false));
       }
       options
           .getLogger()
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java
index 16e96979454..86b13309354 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java
@@ -6,6 +6,7 @@
 
 import android.app.Activity;
 import android.graphics.Bitmap;
+import android.view.View;
 import io.sentry.Attachment;
 import io.sentry.EventProcessor;
 import io.sentry.Hint;
@@ -14,9 +15,16 @@
 import io.sentry.android.core.internal.util.AndroidCurrentDateProvider;
 import io.sentry.android.core.internal.util.Debouncer;
 import io.sentry.android.core.internal.util.ScreenshotUtils;
+import io.sentry.android.replay.util.MaskRenderer;
+import io.sentry.android.replay.util.ViewsKt;
+import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode;
 import io.sentry.protocol.SentryTransaction;
 import io.sentry.util.HintUtils;
 import io.sentry.util.Objects;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -34,10 +42,15 @@ public final class ScreenshotEventProcessor implements EventProcessor {
   private final @NotNull Debouncer debouncer;
   private static final long DEBOUNCE_WAIT_TIME_MS = 2000;
   private static final int DEBOUNCE_MAX_EXECUTIONS = 3;
+  private static final long MASKING_TIMEOUT_MS = 2000;
+
+  private final boolean isReplayAvailable;
+  private final AtomicBoolean isReplayModuleAbsenceLogged = new AtomicBoolean(false);
 
   public ScreenshotEventProcessor(
       final @NotNull SentryAndroidOptions options,
-      final @NotNull BuildInfoProvider buildInfoProvider) {
+      final @NotNull BuildInfoProvider buildInfoProvider,
+      final boolean isReplayAvailable) {
     this.options = Objects.requireNonNull(options, "SentryAndroidOptions is required");
     this.buildInfoProvider =
         Objects.requireNonNull(buildInfoProvider, "BuildInfoProvider is required");
@@ -47,11 +60,17 @@ public ScreenshotEventProcessor(
             DEBOUNCE_WAIT_TIME_MS,
             DEBOUNCE_MAX_EXECUTIONS);
 
+    this.isReplayAvailable = isReplayAvailable;
+
     if (options.isAttachScreenshot()) {
       addIntegrationToSdkVersion("Screenshot");
     }
   }
 
+  private boolean isMaskingEnabled() {
+    return !options.getScreenshot().getMaskViewClasses().isEmpty() && isReplayAvailable;
+  }
+
   @Override
   public @NotNull SentryTransaction process(
       @NotNull SentryTransaction transaction, @NotNull Hint hint) {
@@ -71,6 +90,15 @@ public ScreenshotEventProcessor(
 
       return event;
     }
+    if (!isReplayAvailable && !options.getScreenshot().getMaskViewClasses().isEmpty()) {
+      if (!isReplayModuleAbsenceLogged.getAndSet(true)) {
+        options
+            .getLogger()
+            .log(SentryLevel.WARNING, "Screenshot masking requires sentry-android-replay module");
+      }
+      return event;
+    }
+
     final @Nullable Activity activity = CurrentActivityHolder.getInstance().getActivity();
     if (activity == null || HintUtils.isFromHybridSdk(hint)) {
       return event;
@@ -89,16 +117,32 @@ public ScreenshotEventProcessor(
       return event;
     }
 
-    final Bitmap screenshot =
+    Bitmap screenshot =
         captureScreenshot(
             activity, options.getThreadChecker(), options.getLogger(), buildInfoProvider);
     if (screenshot == null) {
       return event;
     }
 
+    // Apply masking if enabled and replay module is available
+    if (isMaskingEnabled()) {
+      final @Nullable ViewHierarchyNode rootNode = captureViewHierarchy(activity);
+      if (rootNode == null) {
+        screenshot.recycle();
+        return event;
+      }
+      final @Nullable Bitmap masked = applyMasking(screenshot, rootNode);
+      if (masked == null) {
+        // applyMasking already recycles its bitmaps on failure
+        return event;
+      }
+      screenshot = masked;
+    }
+
+    final Bitmap finalScreenshot = screenshot;
     hint.setScreenshot(
         Attachment.fromByteProvider(
-            () -> ScreenshotUtils.compressBitmapToPng(screenshot, options.getLogger()),
+            () -> ScreenshotUtils.compressBitmapToPng(finalScreenshot, options.getLogger()),
             "screenshot.png",
             "image/png",
             false));
@@ -106,6 +150,102 @@ public ScreenshotEventProcessor(
     return event;
   }
 
+  /**
+   * Captures the view hierarchy on the main thread, since view traversal requires it. If already on
+   * the main thread, captures directly; otherwise posts to the main thread and waits.
+   */
+  private @Nullable ViewHierarchyNode captureViewHierarchy(final @NotNull Activity activity) {
+    if (options.getThreadChecker().isMainThread()) {
+      return buildViewHierarchy(activity);
+    }
+
+    final AtomicReference<ViewHierarchyNode> result = new AtomicReference<>(null);
+    final CountDownLatch latch = new CountDownLatch(1);
+
+    try {
+      activity.runOnUiThread(
+          () -> {
+            try {
+              result.set(buildViewHierarchy(activity));
+            } finally {
+              latch.countDown();
+            }
+          });
+
+      if (!latch.await(MASKING_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
+        options
+            .getLogger()
+            .log(
+                SentryLevel.WARNING, "Timed out waiting for view hierarchy capture on main thread");
+        return null;
+      }
+    } catch (Throwable e) {
+      options.getLogger().log(SentryLevel.ERROR, "Failed to capture view hierarchy", e);
+      return null;
+    }
+
+    return result.get();
+  }
+
+  private @Nullable ViewHierarchyNode buildViewHierarchy(final @NotNull Activity activity) {
+    try {
+      final @Nullable View rootView =
+          activity.getWindow() != null
+                  && activity.getWindow().peekDecorView() != null
+                  && activity.getWindow().peekDecorView().getRootView() != null
+              ? activity.getWindow().peekDecorView().getRootView()
+              : null;
+      if (rootView == null) {
+        return null;
+      }
+
+      final ViewHierarchyNode rootNode =
+          ViewHierarchyNode.Companion.fromView(rootView, null, 0, options.getScreenshot());
+      ViewsKt.traverse(rootView, rootNode, options.getScreenshot(), options.getLogger());
+      return rootNode;
+    } catch (Throwable e) {
+      options.getLogger().log(SentryLevel.ERROR, "Failed to build view hierarchy", e);
+      return null;
+    }
+  }
+
+  private @Nullable Bitmap applyMasking(
+      final @NotNull Bitmap screenshot, final @NotNull ViewHierarchyNode rootNode) {
+    Bitmap mutableBitmap = screenshot;
+    boolean createdCopy = false;
+    try (final MaskRenderer maskRenderer = new MaskRenderer()) {
+      // Make bitmap mutable if needed
+      if (!screenshot.isMutable()) {
+        mutableBitmap = screenshot.copy(Bitmap.Config.ARGB_8888, true);
+        if (mutableBitmap == null) {
+          screenshot.recycle();
+          return null;
+        }
+        createdCopy = true;
+      }
+
+      maskRenderer.renderMasks(mutableBitmap, rootNode, null);
+
+      // Recycle original if we created a copy
+      if (createdCopy && !screenshot.isRecycled()) {
+        screenshot.recycle();
+      }
+
+      return mutableBitmap;
+    } catch (Throwable e) {
+      options.getLogger().log(SentryLevel.ERROR, "Failed to mask screenshot", e);
+      if (createdCopy) {
+        if (!mutableBitmap.isRecycled()) {
+          mutableBitmap.recycle();
+        }
+      }
+      if (!screenshot.isRecycled()) {
+        screenshot.recycle();
+      }
+      return null;
+    }
+  }
+
   @Override
   public @Nullable Long getOrder() {
     return 10000L;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
index d106f63e75b..9630fd59618 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
@@ -243,6 +243,15 @@ public interface BeforeCaptureCallback {
 
   private boolean enableTombstone = false;
 
+  /**
+   * Screenshot masking options. Configure which views should be masked when capturing screenshots
+   * on error events.
+   *
+   * <p>Note: Screenshot masking requires the {@code sentry-android-replay} module to be present at
+   * runtime. If the replay module is not available, screenshots will be captured without masking.
+   */
+  private final @NotNull SentryScreenshotOptions screenshot = new SentryScreenshotOptions();
+
   public SentryAndroidOptions() {
     setSentryClientName(BuildConfig.SENTRY_ANDROID_SDK_NAME + "/" + BuildConfig.VERSION_NAME);
     setSdkVersion(createSdkVersion());
@@ -677,6 +686,15 @@ public void setEnableSystemEventBreadcrumbsExtras(
     this.enableSystemEventBreadcrumbsExtras = enableSystemEventBreadcrumbsExtras;
   }
 
+  /**
+   * Returns the screenshot masking options.
+   *
+   * @return the screenshot masking options
+   */
+  public @NotNull SentryScreenshotOptions getScreenshot() {
+    return screenshot;
+  }
+
   static class AndroidUserFeedbackIDialogHandler implements SentryFeedbackOptions.IDialogHandler {
     @Override
     public void showDialog(
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryScreenshotOptions.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryScreenshotOptions.java
new file mode 100644
index 00000000000..8680ed907d1
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryScreenshotOptions.java
@@ -0,0 +1,60 @@
+package io.sentry.android.core;
+
+import io.sentry.SentryMaskingOptions;
+
+/**
+ * Screenshot masking options for error screenshots. Extends the base {@link SentryMaskingOptions}
+ * with screenshot-specific defaults.
+ *
+ * <p>By default, masking is disabled for screenshots. Enable masking by calling {@link
+ * #setMaskAllText(boolean)} and/or {@link #setMaskAllImages(boolean)}.
+ *
+ * <p>Note: Screenshot masking requires the {@code sentry-android-replay} module to be present at
+ * runtime. If the replay module is not available, screenshots will be captured without masking.
+ */
+public final class SentryScreenshotOptions extends SentryMaskingOptions {
+
+  public SentryScreenshotOptions() {
+    // Default to NO masking until next major version.
+    // maskViewClasses starts empty, so nothing is masked by default.
+  }
+
+  @Override
+  public void trackCustomMasking() {
+    // No-op for screenshots, custom masking tracking is only relevant for session replay.
+  }
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>When enabling image masking for screenshots, this also adds masking for WebView, VideoView,
+   * and media player views (ExoPlayer, Media3) since they may contain sensitive content.
+   */
+  @Override
+  public void setMaskAllImages(final boolean maskAllImages) {
+    super.setMaskAllImages(maskAllImages);
+    if (maskAllImages) {
+      addSensitiveViewClasses();
+    } else {
+      removeSensitiveViewClasses();
+    }
+  }
+
+  private void addSensitiveViewClasses() {
+    addMaskViewClass(WEB_VIEW_CLASS_NAME);
+    addMaskViewClass(VIDEO_VIEW_CLASS_NAME);
+    addMaskViewClass(CAMERAX_PREVIEW_VIEW_CLASS_NAME);
+    addMaskViewClass(ANDROIDX_MEDIA_VIEW_CLASS_NAME);
+    addMaskViewClass(EXOPLAYER_CLASS_NAME);
+    addMaskViewClass(EXOPLAYER_STYLED_CLASS_NAME);
+  }
+
+  private void removeSensitiveViewClasses() {
+    getMaskViewClasses().remove(WEB_VIEW_CLASS_NAME);
+    getMaskViewClasses().remove(VIDEO_VIEW_CLASS_NAME);
+    getMaskViewClasses().remove(CAMERAX_PREVIEW_VIEW_CLASS_NAME);
+    getMaskViewClasses().remove(ANDROIDX_MEDIA_VIEW_CLASS_NAME);
+    getMaskViewClasses().remove(EXOPLAYER_CLASS_NAME);
+    getMaskViewClasses().remove(EXOPLAYER_STYLED_CLASS_NAME);
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index 36a0a531a64..c8e55ffc095 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -2289,4 +2289,76 @@ class ManifestMetadataReaderTest {
     assertTrue(fixture.options.isEnableSpotlight)
     assertEquals(expectedUrl, fixture.options.spotlightConnectionUrl)
   }
+
+  // Screenshot masking tests
+
+  @Test
+  fun `applyMetadata reads screenshot mask-all-text to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.SCREENSHOT_MASK_ALL_TEXT to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.screenshot.maskViewClasses.contains("android.widget.TextView"))
+  }
+
+  @Test
+  fun `applyMetadata reads screenshot mask-all-images to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.SCREENSHOT_MASK_ALL_IMAGES to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.screenshot.maskViewClasses.contains("android.widget.ImageView"))
+  }
+
+  @Test
+  fun `applyMetadata without specifying screenshot mask-all-text, stays false`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertFalse(fixture.options.screenshot.maskViewClasses.contains("android.widget.TextView"))
+  }
+
+  @Test
+  fun `applyMetadata without specifying screenshot mask-all-images, stays false`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertFalse(fixture.options.screenshot.maskViewClasses.contains("android.widget.ImageView"))
+  }
+
+  @Test
+  fun `applyMetadata reads both screenshot masking options`() {
+    // Arrange
+    val bundle =
+      bundleOf(
+        ManifestMetadataReader.SCREENSHOT_MASK_ALL_TEXT to true,
+        ManifestMetadataReader.SCREENSHOT_MASK_ALL_IMAGES to true,
+      )
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.screenshot.maskViewClasses.contains("android.widget.TextView"))
+    assertTrue(fixture.options.screenshot.maskViewClasses.contains("android.widget.ImageView"))
+    // maskAllImages should also add WebView
+    assertTrue(fixture.options.screenshot.maskViewClasses.contains("android.webkit.WebView"))
+  }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt
index fac4fdc1891..acc38228e6b 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt
@@ -1,9 +1,24 @@
 package io.sentry.android.core
 
 import android.app.Activity
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.drawable.Drawable
+import android.os.Bundle
+import android.os.Looper
 import android.view.View
-import android.view.Window
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.LinearLayout.LayoutParams
+import android.widget.RadioButton
+import android.widget.TextView
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.dropbox.differ.Color as DifferColor
+import com.dropbox.differ.Image
+import com.dropbox.differ.SimpleImageComparator
 import io.sentry.Attachment
 import io.sentry.Hint
 import io.sentry.MainEventProcessor
@@ -12,6 +27,7 @@ import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.TypeCheckHint.ANDROID_ACTIVITY
 import io.sentry.protocol.SentryException
 import io.sentry.util.thread.IThreadChecker
+import java.io.File
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -21,40 +37,51 @@ import kotlin.test.assertNull
 import kotlin.test.assertSame
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
-import org.mockito.kotlin.any
 import org.mockito.kotlin.mock
-import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
+import org.robolectric.Robolectric.buildActivity
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
+import org.robolectric.shadows.ShadowPixelCopy
 
 @RunWith(AndroidJUnit4::class)
+@Config(shadows = [ShadowPixelCopy::class], sdk = [30])
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
 class ScreenshotEventProcessorTest {
+
+  companion object {
+    /**
+     * Set to `true` to record/update golden images for snapshot tests. When `true`, screenshots
+     * will be saved to src/test/resources/snapshots/{testName}.png. Set back to `false` after
+     * recording to run comparison tests.
+     */
+    private const val RECORD_SNAPSHOTS = false
+
+    private val SNAPSHOTS_DIR =
+      File("src/test/resources/snapshots/ScreenshotEventProcessorTest").also {
+        if (RECORD_SNAPSHOTS) it.mkdirs()
+      }
+  }
+
   private class Fixture {
-    val buildInfo = mock<BuildInfoProvider>()
-    val activity = mock<Activity>()
-    val window = mock<Window>()
-    val view = mock<View>()
-    val rootView = mock<View>()
+    lateinit var activity: Activity
     val threadChecker = mock<IThreadChecker>()
     val options = SentryAndroidOptions().apply { dsn = "https://key@sentry.io/proj" }
     val mainProcessor = MainEventProcessor(options)
 
     init {
-      whenever(rootView.width).thenReturn(1)
-      whenever(rootView.height).thenReturn(1)
-      whenever(view.rootView).thenReturn(rootView)
-      whenever(window.decorView).thenReturn(view)
-      whenever(window.peekDecorView()).thenReturn(view)
-      whenever(activity.window).thenReturn(window)
-      whenever(activity.runOnUiThread(any())).then { it.getArgument<Runnable>(0).run() }
-
       whenever(threadChecker.isMainThread).thenReturn(true)
     }
 
-    fun getSut(attachScreenshot: Boolean = false): ScreenshotEventProcessor {
+    fun getSut(
+      attachScreenshot: Boolean = false,
+      isReplayAvailable: Boolean = false,
+    ): ScreenshotEventProcessor {
       options.isAttachScreenshot = attachScreenshot
       options.threadChecker = threadChecker
 
-      return ScreenshotEventProcessor(options, buildInfo)
+      return ScreenshotEventProcessor(options, BuildInfoProvider(options.logger), isReplayAvailable)
     }
   }
 
@@ -62,8 +89,12 @@ class ScreenshotEventProcessorTest {
 
   @BeforeTest
   fun `set up`() {
+    System.setProperty("robolectric.areWindowsMarkedVisible", "true")
+    System.setProperty("robolectric.pixelCopyRenderMode", "hardware")
+
     fixture = Fixture()
     CurrentActivityHolder.getInstance().clearActivity()
+    fixture.activity = buildActivity(MaskingActivity::class.java, null).setup().get()
   }
 
   @Test
@@ -108,7 +139,7 @@ class ScreenshotEventProcessorTest {
     val sut = fixture.getSut(true)
     val hint = Hint()
 
-    whenever(fixture.activity.isFinishing).thenReturn(true)
+    fixture.activity.finish()
     CurrentActivityHolder.getInstance().setActivity(fixture.activity)
 
     val event = fixture.mainProcessor.process(getEvent(), hint)
@@ -122,8 +153,8 @@ class ScreenshotEventProcessorTest {
     val sut = fixture.getSut(true)
     val hint = Hint()
 
-    whenever(fixture.rootView.width).thenReturn(0)
-    whenever(fixture.rootView.height).thenReturn(0)
+    val root = fixture.activity.window.decorView
+    root.layout(0, 0, 0, 0)
     CurrentActivityHolder.getInstance().setActivity(fixture.activity)
 
     val event = fixture.mainProcessor.process(getEvent(), hint)
@@ -165,6 +196,7 @@ class ScreenshotEventProcessorTest {
   }
 
   @Test
+  @Config(sdk = [23])
   fun `when screenshot event processor is called from background thread it executes on main thread`() {
     val sut = fixture.getSut(true)
     whenever(fixture.threadChecker.isMainThread).thenReturn(false)
@@ -175,7 +207,7 @@ class ScreenshotEventProcessorTest {
     val event = fixture.mainProcessor.process(getEvent(), hint)
     sut.process(event, hint)
 
-    verify(fixture.activity).runOnUiThread(any())
+    shadowOf(Looper.getMainLooper()).idle()
     assertNotNull(hint.screenshot)
   }
 
@@ -291,5 +323,209 @@ class ScreenshotEventProcessorTest {
     assertNotNull(hint.screenshot)
   }
 
+  @Test
+  fun `when masking is configured and VH capture fails, no screenshot is attached`() {
+    val sut = fixture.getSut(attachScreenshot = true, isReplayAvailable = true)
+    fixture.options.screenshot.setMaskAllText(true)
+    val hint = Hint()
+
+    // No activity set, so VH capture will return null (no rootView)
+    CurrentActivityHolder.getInstance().clearActivity()
+
+    val event = fixture.mainProcessor.process(getEvent(), hint)
+    sut.process(event, hint)
+
+    assertNull(hint.screenshot)
+  }
+
+  @Test
+  fun `when masking is configured but replay is not available, screenshot is not captured`() {
+    val sut = fixture.getSut(attachScreenshot = true, isReplayAvailable = false)
+    fixture.options.screenshot.setMaskAllText(true)
+    val hint = Hint()
+
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+
+    val event = fixture.mainProcessor.process(getEvent(), hint)
+    sut.process(event, hint)
+
+    assertNull(hint.screenshot)
+  }
+
+  @Test
+  fun `when masking is configured from background thread, VH is captured on main thread`() {
+    fixture.options.screenshot.setMaskAllText(true)
+    val sut = fixture.getSut(attachScreenshot = true, isReplayAvailable = true)
+    whenever(fixture.threadChecker.isMainThread).thenReturn(false)
+
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+
+    val hint = Hint()
+    val event = fixture.mainProcessor.process(getEvent(), hint)
+    sut.process(event, hint)
+
+    shadowOf(Looper.getMainLooper()).idle()
+    assertNotNull(hint.screenshot)
+  }
+
+  // region Snapshot Tests
+
+  @Test
+  fun `snapshot - screenshot without masking`() {
+    val bytes = processEventForSnapshots("screenshot_no_masking", isReplayAvailable = false)
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - screenshot with text masking enabled`() {
+    val bytes =
+      processEventForSnapshots("screenshot_mask_text") { it.screenshot.setMaskAllText(true) }
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - screenshot with image masking enabled`() {
+    val bytes =
+      processEventForSnapshots("screenshot_mask_images") { it.screenshot.setMaskAllImages(true) }
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - screenshot with all masking enabled`() {
+    val bytes =
+      processEventForSnapshots("screenshot_mask_all") {
+        it.screenshot.setMaskAllText(true)
+        it.screenshot.setMaskAllImages(true)
+      }
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - screenshot with custom view masking`() {
+    val bytes =
+      processEventForSnapshots("screenshot_mask_custom_view") {
+        // CustomView draws white, so masking it should draw black on top
+        it.screenshot.addMaskViewClass(CustomView::class.java.name)
+      }
+    assertNotNull(bytes)
+  }
+
+  // endregion
+
   private fun getEvent(): SentryEvent = SentryEvent(Throwable("Throwable"))
+
+  /**
+   * Helper method for snapshot testing. Processes an event and captures a screenshot, then either
+   * saves it as a golden image (when RECORD_SNAPSHOTS=true) or compares it against an existing
+   * golden image.
+   *
+   * @param testName The name used for the golden image file (without extension)
+   * @param attachScreenshot Whether to enable screenshot attachment
+   * @param isReplayAvailable Whether the replay module is available (enables masking)
+   * @param configureOptions Lambda to configure additional options before processing
+   * @return The captured screenshot bytes, or null if no screenshot was captured
+   */
+  private fun processEventForSnapshots(
+    testName: String,
+    attachScreenshot: Boolean = true,
+    isReplayAvailable: Boolean = true,
+    configureOptions: (SentryAndroidOptions) -> Unit = {},
+  ): ByteArray? {
+    configureOptions(fixture.options)
+    val sut = fixture.getSut(attachScreenshot, isReplayAvailable)
+    val hint = Hint()
+
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+
+    val event = fixture.mainProcessor.process(getEvent(), hint)
+    sut.process(event, hint)
+
+    val screenshot = hint.screenshot ?: return null
+    val bytes = screenshot.bytes ?: screenshot.byteProvider?.call() ?: return null
+
+    val snapshotFile = File(SNAPSHOTS_DIR, "$testName.png")
+    if (RECORD_SNAPSHOTS) {
+      snapshotFile.writeBytes(bytes)
+      println("Recorded snapshot: ${snapshotFile.absolutePath}")
+    } else if (snapshotFile.exists()) {
+      val expectedBitmap = BitmapFactory.decodeFile(snapshotFile.absolutePath)
+      val actualBitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+
+      val result =
+        SimpleImageComparator(maxDistance = 0.01f)
+          .compare(BitmapImage(expectedBitmap), BitmapImage(actualBitmap))
+      assertEquals(
+        0,
+        result.pixelDifferences,
+        "Screenshot does not match golden image: ${snapshotFile.absolutePath}. " +
+          "Pixel differences: ${result.pixelDifferences}",
+      )
+    }
+
+    return bytes
+  }
+
+  /** Adapter to wrap Android Bitmap for use with dropbox/differ library */
+  private class BitmapImage(private val bitmap: Bitmap) : Image {
+    override val height: Int
+      get() = bitmap.height
+
+    override val width: Int
+      get() = bitmap.width
+
+    override fun getPixel(x: Int, y: Int): DifferColor = DifferColor(bitmap.getPixel(x, y))
+  }
+}
+
+private class CustomView(context: Context) : View(context) {
+  override fun onDraw(canvas: Canvas) {
+    super.onDraw(canvas)
+    canvas.drawColor(Color.WHITE)
+  }
+}
+
+private class MaskingActivity : Activity() {
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val linearLayout =
+      LinearLayout(this).apply {
+        setBackgroundColor(android.R.color.white)
+        orientation = LinearLayout.VERTICAL
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+      }
+
+    val textView =
+      TextView(this).apply {
+        text = "Hello, World!"
+        layoutParams = LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT)
+      }
+    linearLayout.addView(textView)
+
+    val image = this::class.java.classLoader?.getResource("Tongariro.jpg")!!
+    val imageView =
+      ImageView(this).apply {
+        setImageDrawable(Drawable.createFromPath(image.path))
+        layoutParams = LayoutParams(50, 50).apply { setMargins(0, 16, 0, 0) }
+      }
+    linearLayout.addView(imageView)
+
+    val radioButton =
+      RadioButton(this).apply {
+        text = "Radio Button"
+        layoutParams =
+          LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT).apply {
+            setMargins(0, 16, 0, 0)
+          }
+      }
+    linearLayout.addView(radioButton)
+
+    val customView =
+      CustomView(this).apply {
+        layoutParams = LayoutParams(50, 50).apply { setMargins(0, 16, 0, 0) }
+      }
+    linearLayout.addView(customView)
+
+    setContentView(linearLayout)
+  }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryScreenshotOptionsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryScreenshotOptionsTest.kt
new file mode 100644
index 00000000000..ad6d29b5614
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryScreenshotOptionsTest.kt
@@ -0,0 +1,113 @@
+package io.sentry.android.core
+
+import io.sentry.SentryMaskingOptions
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class SentryScreenshotOptionsTest {
+
+  @Test
+  fun `maskViewClasses is empty by default`() {
+    val options = SentryScreenshotOptions()
+    assertTrue(options.maskViewClasses.isEmpty())
+  }
+
+  @Test
+  fun `unmaskViewClasses is empty by default`() {
+    val options = SentryScreenshotOptions()
+    assertTrue(options.unmaskViewClasses.isEmpty())
+  }
+
+  @Test
+  fun `setMaskAllText true only adds TextView`() {
+    val options = SentryScreenshotOptions()
+    options.setMaskAllText(true)
+
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.TEXT_VIEW_CLASS_NAME))
+    // Should NOT add sensitive view classes (only setMaskAllImages does that)
+    assertFalse(options.maskViewClasses.contains(SentryMaskingOptions.WEB_VIEW_CLASS_NAME))
+    assertFalse(options.maskViewClasses.contains(SentryMaskingOptions.VIDEO_VIEW_CLASS_NAME))
+    assertEquals(1, options.maskViewClasses.size)
+  }
+
+  @Test
+  fun `setMaskAllImages true adds ImageView and sensitive view classes`() {
+    val options = SentryScreenshotOptions()
+    options.setMaskAllImages(true)
+
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME))
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.WEB_VIEW_CLASS_NAME))
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.VIDEO_VIEW_CLASS_NAME))
+    assertTrue(
+      options.maskViewClasses.contains(SentryMaskingOptions.CAMERAX_PREVIEW_VIEW_CLASS_NAME)
+    )
+    assertTrue(
+      options.maskViewClasses.contains(SentryMaskingOptions.ANDROIDX_MEDIA_VIEW_CLASS_NAME)
+    )
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.EXOPLAYER_CLASS_NAME))
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.EXOPLAYER_STYLED_CLASS_NAME))
+  }
+
+  @Test
+  fun `setMaskAllImages false does not add sensitive view classes`() {
+    val options = SentryScreenshotOptions()
+    options.setMaskAllImages(false)
+
+    assertFalse(options.maskViewClasses.contains(SentryMaskingOptions.WEB_VIEW_CLASS_NAME))
+    assertFalse(options.maskViewClasses.contains(SentryMaskingOptions.VIDEO_VIEW_CLASS_NAME))
+    assertTrue(options.unmaskViewClasses.contains(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME))
+  }
+
+  @Test
+  fun `calling setMaskAllImages true multiple times does not duplicate classes`() {
+    val options = SentryScreenshotOptions()
+    options.setMaskAllImages(true)
+    options.setMaskAllImages(true)
+    options.setMaskAllImages(true)
+
+    // CopyOnWriteArraySet should prevent duplicates
+    assertEquals(7, options.maskViewClasses.size)
+  }
+
+  @Test
+  fun `inherits addMaskViewClass from base class`() {
+    val options = SentryScreenshotOptions()
+    options.addMaskViewClass("com.example.CustomView")
+
+    assertTrue(options.maskViewClasses.contains("com.example.CustomView"))
+  }
+
+  @Test
+  fun `inherits addUnmaskViewClass from base class`() {
+    val options = SentryScreenshotOptions()
+    options.addUnmaskViewClass("com.example.SafeView")
+
+    assertTrue(options.unmaskViewClasses.contains("com.example.SafeView"))
+  }
+
+  @Test
+  fun `inherits container class methods from base class`() {
+    val options = SentryScreenshotOptions()
+    options.setMaskViewContainerClass("com.example.MaskContainer")
+    options.setUnmaskViewContainerClass("com.example.UnmaskContainer")
+
+    assertEquals("com.example.MaskContainer", options.maskViewContainerClass)
+    assertEquals("com.example.UnmaskContainer", options.unmaskViewContainerClass)
+  }
+
+  @Test
+  fun `setMaskAllImages false removes sensitive view classes added by true`() {
+    val options = SentryScreenshotOptions()
+    options.setMaskAllImages(true)
+
+    // Verify classes were added
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.WEB_VIEW_CLASS_NAME))
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.VIDEO_VIEW_CLASS_NAME))
+
+    options.setMaskAllImages(false)
+
+    assertTrue(options.maskViewClasses.isEmpty())
+  }
+}
diff --git a/sentry-android-core/src/test/resources/Tongariro.jpg b/sentry-android-core/src/test/resources/Tongariro.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..96e2f074f0d56243385f5d0a56972d54ffc9e333
GIT binary patch
literal 239154
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%0Dx`y;G6#d
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

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_all.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_all.png
new file mode 100644
index 0000000000000000000000000000000000000000..31ba5f581bcfc891c1c1eef20d9106580c53c0ae
GIT binary patch
literal 2673
zcmeAS@N?(olHy`uVBq!ia0y~yU~~ZDYaDDq5w`UKUw{;2age(c!@6@aFM%AEVkgfK
z4j`!ENa<i;;F9)qaSW-L^Y-q3Kj}>AV-MM<h}f~d5n7Tfb5m9Hs2FE#fK`U2PSiFP
z)yy!itJ6F#tYPtLt>s$sSUc?7^m;Q1e~AyZv8h7-ayn0^m)krpzqabtItHe-+ie*f
zqFDqwR2v+07+I1y6$HE)8Y7rEjtDs@Ok-f$h$8j+>U*0Xcjxw|HQc;*?b@xszh9f@
zw5!$}P`bsHxR_DIE<w^?_RujqW)b^@NdLQn;*Jdwy(|}A@n@V0{&s{*pkr$Z!`goh
z%WOl#*Wk7U!+xNy+jT2AH&o4Ar5)Dbu*QukLzKhhsb+N&E60&6orbW+1DodUQkLuC
z+mfd$*Yi(Vk>y$D?=v5_vk5$~EEZ%T&Tk-V*RwSr)USX1=g*%`_e#6A!-=<*8T=D+
z4J2x|%Z3&GsB`5>EUhi)(y6omJnz7(S!@^VzueqozG2q2)qj}lIo=Ddkqd7W|M2hc
z?``f3Qd{y;KNsZMA7IV6c5ANtcHJYPi4n4XjVOUzz?gr3Uv4$a0>{_uvh41>zP|pp
z9Am}=(FaW1wr>Y9FO--|n7f?czIShI{QkP!YMup-mqix@KfKv?c;SzOT)*ClM6lF9
zvu(Wk^>W*a`(C!XVzws?%o`Y1p9xLCj6aN^MUD0K&;CA}f4ko1sto_9@Am(<*)nZ#
zs@tjfs+jwJe~UoIp>oEWcMpG06ks|%qmJ#zrAOgkjndiX@q?oIb*O%|>eor>?6*>Z
zkrEZ(Dtblh56^+io0$luDFSZ7krD~$dR_njbN+2(om|m6wg)dG8JRX-TOId}>y_$x
zzAdML3DK1Ifp?7O-Xk*`pC<#O_s-uR-Sv6@FCNq3SF3Rlu9G~_`CQEDA@eK~a8SAm
zkQ|iQoV_>d3+vyy{k!hw<>uywZoj>D)vAjbA>rZSrc%AHK7HCW@!+}h=cO&rt&-qt
z&+TW>etxk3=$o%qTlep`@4ct9_~MFxzh1B3wR30X6^BFR_J%EKHX04PckllC?(XhY
ztEBpmmlhTVUcY|*@`<lidvD#jv&KCC-j!p=+(JX=&YO2_x&M4IDYrjzek_TV-`PIg
z{xNs%+^Z)~o;+iJ`(;U1dHMFTva(gHUOhhE|MlnR=j^;nb=|^_5$Eo7E9{NSm)gI0
z@#38ySFhT&ckkNClP6nQS*=>NYVY2?ufA4&=Toffe_Y%A^bGHVg9jZ$|8D;j{p8WH
zr%zLXHiU*={rB&m&|}6wcE-#%-ha<dPF{TM@yET|`{ONbZP$LRh`F1${ny`rXYA8O
znYW~-F{m$JCoV4DZ}s8r+qYk~@>}vgEBwRG)NgLw5FH&I8d_Rg`}ak&f1I_Y*nwgr
z<A%w%Bju{??{8l}SBCq6<;PG9g==RR`i?(d74`1(?vvT-$C)bp(%3${dIfZ@nYp=q
z?FW$HqRRMvHJQ~c6&uso3O@ae-G6_*-}22L8m;G^`|@pi<$UE|X3Q6+&1BrOXV08_
z$F~E+_(NlPdHL$wZ?9F@<mI$WG^m~3%TZKQ6B8P0ZEangpY|_s|NZ%O@)borm1~&f
z(=BAKwe!p0l4Firvy*Yp&Yd&gy(p@vh^VfvF7|J?p6dtn+|`E<6M<nRdB{0`vEad@
z75ft^x%1nBDPh^|#9p_>z^EwOefjMMwco6In}pA7ui5;t?h*Uhhz#c|&CSi#`B`$n
z_^zqhbA|VcaMF+ZMeJv*3mDXY{jCGV{jFQGjuqI*UB7xY^zNNIJ039Zk>F+*NC^F*
zC4;YYCy=KQN&4EmckjX;tt^-~n_K4;FgKx=A_#RTbqCR=(?Zu)GYOt|x8#@>@B%9k
t!u8yMx^?h}=BNv?H;)D;*<Ab2u&S*gFhWOQ3b5J8;OXk;vd$@?2>?^=z1{!-

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_custom_view.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_custom_view.png
new file mode 100644
index 0000000000000000000000000000000000000000..217c73490cec235b4b9a07fb87fcc4c371a5f406
GIT binary patch
literal 14948
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

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_images.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_images.png
new file mode 100644
index 0000000000000000000000000000000000000000..bd4378a9947ef6999486f1371bee3e56f596157c
GIT binary patch
literal 9353
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

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_text.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_text.png
new file mode 100644
index 0000000000000000000000000000000000000000..952fd6ba634e63272feab38bb17f8ee73e2b2267
GIT binary patch
literal 8428
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
IWgPH708JuWuK)l5

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_no_masking.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_no_masking.png
new file mode 100644
index 0000000000000000000000000000000000000000..edf883f9a4b2e02ae1474341e7ac01264aab81f3
GIT binary patch
literal 14845
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
PPCPAjJ+(>|+ZX>0n>sh_

literal 0
HcmV?d00001

diff --git a/sentry-android-integration-tests/sentry-uitest-android/proguard-rules.pro b/sentry-android-integration-tests/sentry-uitest-android/proguard-rules.pro
index 5de2dac4bdb..396c9025eaf 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/proguard-rules.pro
+++ b/sentry-android-integration-tests/sentry-uitest-android/proguard-rules.pro
@@ -40,4 +40,8 @@
 -dontwarn org.mockito.internal.**
 -dontwarn org.jetbrains.annotations.**
 -dontwarn io.sentry.android.replay.ReplayIntegration
+-dontwarn io.sentry.android.replay.util.MaskRenderer
+-dontwarn io.sentry.android.replay.util.ViewsKt
+-dontwarn io.sentry.android.replay.viewhierarchy.ViewHierarchyNode$Companion
+-dontwarn io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
 -keep class curtains.** { *; }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
index cca6fb35be4..ec3f36647c3 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
@@ -2,12 +2,7 @@ package io.sentry.android.replay.screenshot
 
 import android.annotation.SuppressLint
 import android.graphics.Bitmap
-import android.graphics.Canvas
-import android.graphics.Color
 import android.graphics.Matrix
-import android.graphics.Paint
-import android.graphics.Rect
-import android.graphics.RectF
 import android.view.PixelCopy
 import android.view.View
 import io.sentry.SentryLevel.DEBUG
@@ -19,12 +14,10 @@ import io.sentry.android.replay.ScreenshotRecorderCallback
 import io.sentry.android.replay.ScreenshotRecorderConfig
 import io.sentry.android.replay.phoneWindow
 import io.sentry.android.replay.util.DebugOverlayDrawable
+import io.sentry.android.replay.util.MaskRenderer
 import io.sentry.android.replay.util.ReplayRunnable
-import io.sentry.android.replay.util.getVisibleRects
 import io.sentry.android.replay.util.traverse
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
-import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.ImageViewHierarchyNode
-import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.TextViewHierarchyNode
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.LazyThreadSafetyMode.NONE
 
@@ -39,15 +32,12 @@ internal class PixelCopyStrategy(
 
   private val executor = executorProvider.getExecutor()
   private val mainLooperHandler = executorProvider.getMainLooperHandler()
-  private val singlePixelBitmap: Bitmap by
-    lazy(NONE) { Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888) }
   private val screenshot =
     Bitmap.createBitmap(config.recordingWidth, config.recordingHeight, Bitmap.Config.ARGB_8888)
-  private val singlePixelBitmapCanvas: Canvas by lazy(NONE) { Canvas(singlePixelBitmap) }
   private val prescaledMatrix by
     lazy(NONE) { Matrix().apply { preScale(config.scaleFactorX, config.scaleFactorY) } }
   private val lastCaptureSuccessful = AtomicBoolean(false)
-  private val maskingPaint by lazy(NONE) { Paint() }
+  private val maskRenderer = MaskRenderer()
   private val contentChanged = AtomicBoolean(false)
   private val isClosed = AtomicBoolean(false)
 
@@ -90,8 +80,8 @@ internal class PixelCopyStrategy(
           }
 
           // TODO: disableAllMasking here and dont traverse?
-          val viewHierarchy = ViewHierarchyNode.fromView(root, null, 0, options)
-          root.traverse(viewHierarchy, options)
+          val viewHierarchy = ViewHierarchyNode.fromView(root, null, 0, options.sessionReplay)
+          root.traverse(viewHierarchy, options.sessionReplay, options.logger)
 
           executor.submit(
             ReplayRunnable("screenshot_recorder.mask") {
@@ -100,51 +90,7 @@ internal class PixelCopyStrategy(
                 return@ReplayRunnable
               }
 
-              val debugMasks = mutableListOf<Rect>()
-
-              val canvas = Canvas(screenshot)
-              canvas.setMatrix(prescaledMatrix)
-              viewHierarchy.traverse { node ->
-                if (node.shouldMask && (node.width > 0 && node.height > 0)) {
-                  node.visibleRect ?: return@traverse false
-
-                  // TODO: investigate why it returns true on RN when it shouldn't
-                  //                                    if (viewHierarchy.isObscured(node)) {
-                  //                                        return@traverse true
-                  //                                    }
-
-                  val (visibleRects, color) =
-                    when (node) {
-                      is ImageViewHierarchyNode -> {
-                        listOf(node.visibleRect) to
-                          screenshot.dominantColorForRect(node.visibleRect)
-                      }
-
-                      is TextViewHierarchyNode -> {
-                        val textColor =
-                          node.layout?.dominantTextColor ?: node.dominantColor ?: Color.BLACK
-                        node.layout.getVisibleRects(
-                          node.visibleRect,
-                          node.paddingLeft,
-                          node.paddingTop,
-                        ) to textColor
-                      }
-
-                      else -> {
-                        listOf(node.visibleRect) to Color.BLACK
-                      }
-                    }
-
-                  maskingPaint.setColor(color)
-                  visibleRects.forEach { rect ->
-                    canvas.drawRoundRect(RectF(rect), 10f, 10f, maskingPaint)
-                  }
-                  if (options.replayController.isDebugMaskingOverlayEnabled()) {
-                    debugMasks.addAll(visibleRects)
-                  }
-                }
-                return@traverse true
-              }
+              val debugMasks = maskRenderer.renderMasks(screenshot, viewHierarchy, prescaledMatrix)
 
               if (options.replayController.isDebugMaskingOverlayEnabled()) {
                 mainLooperHandler.post {
@@ -196,35 +142,9 @@ internal class PixelCopyStrategy(
               }
             }
           }
-          // since singlePixelBitmap is only used in tasks within the single threaded executor
-          // there won't be any concurrent access
-          if (!singlePixelBitmap.isRecycled) {
-            singlePixelBitmap.recycle()
-          }
+          maskRenderer.close()
         },
       )
     )
   }
-
-  private fun Bitmap.dominantColorForRect(rect: Rect): Int {
-    if (isClosed.get() || this.isRecycled || singlePixelBitmap.isRecycled) {
-      return Color.BLACK
-    }
-
-    // TODO: maybe this ceremony can be just simplified to
-    // TODO: multiplying the visibleRect by the prescaledMatrix
-    val visibleRect = Rect(rect)
-    val visibleRectF = RectF(visibleRect)
-
-    // since we take screenshot with lower scale, we also
-    // have to apply the same scale to the visibleRect to get the
-    // correct screenshot part to determine the dominant color
-    prescaledMatrix.mapRect(visibleRectF)
-    // round it back to integer values, because drawBitmap below accepts Rect only
-    visibleRectF.round(visibleRect)
-    // draw part of the screenshot (visibleRect) to a single pixel bitmap
-    singlePixelBitmapCanvas.drawBitmap(this, visibleRect, Rect(0, 0, 1, 1), null)
-    // get the pixel color (= dominant color)
-    return singlePixelBitmap.getPixel(0, 0)
-  }
 }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/MaskRenderer.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/MaskRenderer.kt
new file mode 100644
index 00000000000..5e650c9f958
--- /dev/null
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/MaskRenderer.kt
@@ -0,0 +1,118 @@
+package io.sentry.android.replay.util
+
+import android.annotation.SuppressLint
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.Rect
+import android.graphics.RectF
+import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
+import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.ImageViewHierarchyNode
+import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.TextViewHierarchyNode
+import java.io.Closeable
+import kotlin.LazyThreadSafetyMode.NONE
+
+/**
+ * Shared utility for rendering masks on bitmaps based on view hierarchy. Used by both Session
+ * Replay (PixelCopyStrategy) and Screenshot masking.
+ */
+@SuppressLint("UseKtx")
+internal class MaskRenderer : Closeable {
+
+  private companion object {
+    private const val MASK_CORNER_RADIUS = 10f
+  }
+
+  // Single pixel bitmap for dominant color sampling (averaging the region)
+  private val lazySinglePixelBitmap: Lazy<Bitmap> =
+    lazy(NONE) { Bitmap.createBitmap(1, 1, Bitmap.Config.ARGB_8888) }
+  internal val singlePixelBitmap: Bitmap by lazySinglePixelBitmap
+  private val singlePixelBitmapCanvas: Canvas by lazy(NONE) { Canvas(singlePixelBitmap) }
+  private val maskingPaint by lazy(NONE) { Paint() }
+
+  /**
+   * Renders masks onto the given bitmap based on the view hierarchy.
+   *
+   * @param bitmap The bitmap to render masks onto (must be mutable)
+   * @param viewHierarchy The root node of the view hierarchy
+   * @param scaleMatrix Optional matrix for scaling (used by replay for lower resolution)
+   * @return List of masked rectangles (for debug overlay)
+   */
+  fun renderMasks(
+    bitmap: Bitmap,
+    viewHierarchy: ViewHierarchyNode,
+    scaleMatrix: Matrix? = null,
+  ): List<Rect> {
+    if (bitmap.isRecycled) {
+      return emptyList()
+    }
+
+    val maskedRects = mutableListOf<Rect>()
+    val canvas = Canvas(bitmap)
+
+    scaleMatrix?.let { canvas.setMatrix(it) }
+
+    viewHierarchy.traverse { node ->
+      if (node.shouldMask && node.width > 0 && node.height > 0) {
+        node.visibleRect ?: return@traverse false
+
+        val (visibleRects, color) =
+          when (node) {
+            is ImageViewHierarchyNode -> {
+              listOf(node.visibleRect) to
+                dominantColorForRect(bitmap, node.visibleRect, scaleMatrix)
+            }
+            is TextViewHierarchyNode -> {
+              val textColor = node.layout?.dominantTextColor ?: node.dominantColor ?: Color.BLACK
+              node.layout.getVisibleRects(node.visibleRect, node.paddingLeft, node.paddingTop) to
+                textColor
+            }
+            else -> {
+              listOf(node.visibleRect) to Color.BLACK
+            }
+          }
+
+        maskingPaint.color = color
+        visibleRects.forEach { rect ->
+          canvas.drawRoundRect(RectF(rect), MASK_CORNER_RADIUS, MASK_CORNER_RADIUS, maskingPaint)
+        }
+        maskedRects.addAll(visibleRects)
+      }
+      return@traverse true
+    }
+
+    return maskedRects
+  }
+
+  /**
+   * Samples the dominant color from a region of the bitmap by scaling the region down to a single
+   * pixel (averaging all colors in the region).
+   */
+  private fun dominantColorForRect(bitmap: Bitmap, rect: Rect, scaleMatrix: Matrix? = null): Int {
+    if (bitmap.isRecycled || singlePixelBitmap.isRecycled) {
+      return Color.BLACK
+    }
+
+    val visibleRect = Rect(rect)
+    val visibleRectF = RectF(visibleRect)
+
+    // Apply scale matrix if provided (for replay's lower resolution)
+    scaleMatrix?.mapRect(visibleRectF)
+    visibleRectF.round(visibleRect)
+
+    // Draw the region scaled down to 1x1 pixel (averages the colors)
+    singlePixelBitmapCanvas.drawBitmap(bitmap, visibleRect, Rect(0, 0, 1, 1), null)
+
+    // Return the averaged color
+    return singlePixelBitmap.getPixel(0, 0)
+  }
+
+  /** Releases resources. Call when done with this renderer. */
+  override fun close() {
+    if (lazySinglePixelBitmap.isInitialized() && !singlePixelBitmap.isRecycled) {
+      singlePixelBitmap.recycle()
+    }
+  }
+}
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt
index aecc9b0456d..80ca1beee4e 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt
@@ -19,7 +19,8 @@ import android.view.View
 import android.view.ViewGroup
 import android.view.ViewTreeObserver
 import android.widget.TextView
-import io.sentry.SentryOptions
+import io.sentry.ILogger
+import io.sentry.SentryMaskingOptions
 import io.sentry.android.replay.viewhierarchy.ComposeViewHierarchyNode
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
 import java.lang.NullPointerException
@@ -27,14 +28,22 @@ import java.lang.NullPointerException
 /**
  * Recursively traverses the view hierarchy and creates a [ViewHierarchyNode] for each view.
  * Supports Compose view hierarchy as well.
+ *
+ * @param parentNode The parent node in the view hierarchy
+ * @param options The masking configuration to use
+ * @param logger Logger for error reporting during Compose traversal
  */
 @SuppressLint("UseKtx")
-internal fun View.traverse(parentNode: ViewHierarchyNode, options: SentryOptions) {
+internal fun View.traverse(
+  parentNode: ViewHierarchyNode,
+  options: SentryMaskingOptions,
+  logger: ILogger,
+) {
   if (this !is ViewGroup) {
     return
   }
 
-  if (ComposeViewHierarchyNode.fromView(this, parentNode, options)) {
+  if (ComposeViewHierarchyNode.fromView(this, parentNode, options, logger)) {
     // if it's a compose view, we can skip the children as they are already traversed in
     // the ComposeViewHierarchyNode.fromView method
     return
@@ -50,7 +59,7 @@ internal fun View.traverse(parentNode: ViewHierarchyNode, options: SentryOptions
     if (child != null) {
       val childNode = ViewHierarchyNode.fromView(child, parentNode, indexOfChild(child), options)
       childNodes.add(childNode)
-      child.traverse(childNode, options)
+      child.traverse(childNode, options, logger)
     }
   }
   parentNode.children = childNodes
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
index a24a40a2949..2e58418c3ac 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
@@ -17,9 +17,9 @@ import androidx.compose.ui.semantics.SemanticsProperties
 import androidx.compose.ui.semantics.getOrNull
 import androidx.compose.ui.text.TextLayoutResult
 import androidx.compose.ui.unit.TextUnit
+import io.sentry.ILogger
 import io.sentry.SentryLevel
-import io.sentry.SentryOptions
-import io.sentry.SentryReplayOptions
+import io.sentry.SentryMaskingOptions
 import io.sentry.android.replay.SentryReplayModifiers
 import io.sentry.android.replay.util.ComposeTextLayout
 import io.sentry.android.replay.util.boundsInWindow
@@ -70,36 +70,36 @@ internal object ComposeViewHierarchyNode {
    */
   private fun getProxyClassName(isImage: Boolean, config: SemanticsConfiguration?): String =
     when {
-      isImage -> SentryReplayOptions.IMAGE_VIEW_CLASS_NAME
+      isImage -> SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME
       config != null &&
         (config.contains(SemanticsProperties.Text) ||
           config.contains(SemanticsActions.SetText) ||
           config.contains(SemanticsProperties.EditableText)) ->
-        SentryReplayOptions.TEXT_VIEW_CLASS_NAME
+        SentryMaskingOptions.TEXT_VIEW_CLASS_NAME
       else -> "android.view.View"
     }
 
   private fun SemanticsConfiguration?.shouldMask(
     isImage: Boolean,
-    options: SentryOptions,
+    options: SentryMaskingOptions,
   ): Boolean {
     val sentryPrivacyModifier = this?.getOrNull(SentryReplayModifiers.SentryPrivacy)
     if (sentryPrivacyModifier == "unmask") {
-      options.sessionReplay.trackCustomMasking()
+      options.trackCustomMasking()
       return false
     }
 
     if (sentryPrivacyModifier == "mask") {
-      options.sessionReplay.trackCustomMasking()
+      options.trackCustomMasking()
       return true
     }
 
     val className = getProxyClassName(isImage, this)
-    if (options.sessionReplay.unmaskViewClasses.contains(className)) {
+    if (options.unmaskViewClasses.contains(className)) {
       return false
     }
 
-    return options.sessionReplay.maskViewClasses.contains(className)
+    return options.maskViewClasses.contains(className)
   }
 
   @Suppress("ktlint:standard:backing-property-naming")
@@ -110,7 +110,8 @@ internal object ComposeViewHierarchyNode {
     parent: ViewHierarchyNode?,
     distance: Int,
     isComposeRoot: Boolean,
-    options: SentryOptions,
+    options: SentryMaskingOptions,
+    logger: ILogger,
   ): ViewHierarchyNode? {
     val isInTree = node.isPlaced && node.isAttached
     if (!isInTree) {
@@ -129,7 +130,7 @@ internal object ComposeViewHierarchyNode {
     } catch (t: Throwable) {
       if (!semanticsRetrievalErrorLogged) {
         semanticsRetrievalErrorLogged = true
-        options.logger.log(
+        logger.log(
           SentryLevel.ERROR,
           t,
           """
@@ -259,7 +260,12 @@ internal object ComposeViewHierarchyNode {
     }
   }
 
-  fun fromView(view: View, parent: ViewHierarchyNode?, options: SentryOptions): Boolean {
+  fun fromView(
+    view: View,
+    parent: ViewHierarchyNode?,
+    options: SentryMaskingOptions,
+    logger: ILogger,
+  ): Boolean {
     if (!view::class.java.name.contains("AndroidComposeView")) {
       return false
     }
@@ -270,9 +276,9 @@ internal object ComposeViewHierarchyNode {
 
     try {
       val rootNode = (view as? Owner)?.root ?: return false
-      rootNode.traverse(parent, isComposeRoot = true, options)
+      rootNode.traverse(parent, isComposeRoot = true, options, logger)
     } catch (e: Throwable) {
-      options.logger.log(
+      logger.log(
         SentryLevel.ERROR,
         e,
         """
@@ -292,7 +298,8 @@ internal object ComposeViewHierarchyNode {
   private fun LayoutNode.traverse(
     parentNode: ViewHierarchyNode,
     isComposeRoot: Boolean,
-    options: SentryOptions,
+    options: SentryMaskingOptions,
+    logger: ILogger,
   ) {
     val children = this.children
     if (children.isEmpty()) {
@@ -302,10 +309,10 @@ internal object ComposeViewHierarchyNode {
     val childNodes = ArrayList<ViewHierarchyNode>(children.size)
     for (index in children.indices) {
       val child = children[index]
-      val childNode = fromComposeNode(child, parentNode, index, isComposeRoot, options)
+      val childNode = fromComposeNode(child, parentNode, index, isComposeRoot, options, logger)
       if (childNode != null) {
         childNodes.add(childNode)
-        child.traverse(childNode, isComposeRoot = false, options)
+        child.traverse(childNode, isComposeRoot = false, options, logger)
       }
     }
     parentNode.children = childNodes
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ViewHierarchyNode.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ViewHierarchyNode.kt
index 6b66bcef4bb..f54fa79da10 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ViewHierarchyNode.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ViewHierarchyNode.kt
@@ -7,7 +7,7 @@ import android.view.View
 import android.view.ViewParent
 import android.widget.ImageView
 import android.widget.TextView
-import io.sentry.SentryOptions
+import io.sentry.SentryMaskingOptions
 import io.sentry.android.replay.R
 import io.sentry.android.replay.util.AndroidTextLayout
 import io.sentry.android.replay.util.TextLayout
@@ -286,12 +286,12 @@ internal sealed class ViewHierarchyNode(
       return false
     }
 
-    private fun View.shouldMask(options: SentryOptions): Boolean {
+    private fun View.shouldMask(options: SentryMaskingOptions): Boolean {
       if (
         (tag as? String)?.lowercase()?.contains(SENTRY_UNMASK_TAG) == true ||
           getTag(R.id.sentry_privacy) == "unmask"
       ) {
-        options.sessionReplay.trackCustomMasking()
+        options.trackCustomMasking()
         return false
       }
 
@@ -299,7 +299,7 @@ internal sealed class ViewHierarchyNode(
         (tag as? String)?.lowercase()?.contains(SENTRY_MASK_TAG) == true ||
           getTag(R.id.sentry_privacy) == "mask"
       ) {
-        options.sessionReplay.trackCustomMasking()
+        options.trackCustomMasking()
         return true
       }
 
@@ -311,28 +311,33 @@ internal sealed class ViewHierarchyNode(
         return false
       }
 
-      if (this.javaClass.isAssignableFrom(options.sessionReplay.unmaskViewClasses)) {
+      if (this.javaClass.isAssignableFrom(options.unmaskViewClasses)) {
         return false
       }
 
-      return this.javaClass.isAssignableFrom(options.sessionReplay.maskViewClasses)
+      return this.javaClass.isAssignableFrom(options.maskViewClasses)
     }
 
-    private fun ViewParent.isUnmaskContainer(options: SentryOptions): Boolean {
-      val unmaskContainer = options.sessionReplay.unmaskViewContainerClass ?: return false
+    private fun ViewParent.isUnmaskContainer(options: SentryMaskingOptions): Boolean {
+      val unmaskContainer = options.unmaskViewContainerClass ?: return false
       return this.javaClass.name == unmaskContainer
     }
 
-    private fun View.isMaskContainer(options: SentryOptions): Boolean {
-      val maskContainer = options.sessionReplay.maskViewContainerClass ?: return false
+    private fun View.isMaskContainer(options: SentryMaskingOptions): Boolean {
+      val maskContainer = options.maskViewContainerClass ?: return false
       return this.javaClass.name == maskContainer
     }
 
+    /**
+     * Creates a ViewHierarchyNode from a View using SentryMaskingOptions directly. This allows for
+     * reuse with both session replay and screenshot masking.
+     */
+    @JvmStatic
     fun fromView(
       view: View,
       parent: ViewHierarchyNode?,
       distance: Int,
-      options: SentryOptions,
+      options: SentryMaskingOptions,
     ): ViewHierarchyNode {
       val (isVisible, visibleRect) = view.isVisibleToUser()
       val shouldMask = isVisible && view.shouldMask(options)
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/MaskRendererTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/MaskRendererTest.kt
new file mode 100644
index 00000000000..48b98b50c03
--- /dev/null
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/MaskRendererTest.kt
@@ -0,0 +1,326 @@
+package io.sentry.android.replay.util
+
+import android.graphics.Bitmap
+import android.graphics.Color
+import android.graphics.Matrix
+import android.graphics.Rect
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.GenericViewHierarchyNode
+import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.ImageViewHierarchyNode
+import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.TextViewHierarchyNode
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [30])
+class MaskRendererTest {
+
+  @Test
+  fun `renderMasks returns empty list for recycled bitmap`() {
+    val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+    bitmap.recycle()
+
+    val rootNode =
+      GenericViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 100,
+        height = 100,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = Rect(0, 0, 100, 100),
+      )
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, rootNode, null)
+
+    assertTrue(result.isEmpty())
+    renderer.close()
+  }
+
+  @Test
+  fun `renderMasks masks GenericViewHierarchyNode`() {
+    val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+    bitmap.eraseColor(Color.WHITE)
+
+    val rootNode =
+      GenericViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 100,
+        height = 100,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = Rect(10, 10, 90, 90),
+      )
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, rootNode, null)
+
+    assertEquals(1, result.size)
+    assertEquals(Rect(10, 10, 90, 90), result[0])
+    renderer.close()
+  }
+
+  @Test
+  fun `renderMasks masks ImageViewHierarchyNode with dominant color`() {
+    val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+    bitmap.eraseColor(Color.RED)
+
+    val imageNode =
+      ImageViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 100,
+        height = 100,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = Rect(0, 0, 100, 100),
+      )
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, imageNode, null)
+
+    assertEquals(1, result.size)
+    renderer.close()
+  }
+
+  @Test
+  fun `renderMasks masks TextViewHierarchyNode with text color`() {
+    val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+    bitmap.eraseColor(Color.WHITE)
+
+    val textNode =
+      TextViewHierarchyNode(
+        layout = null,
+        dominantColor = Color.BLUE,
+        paddingLeft = 0,
+        paddingTop = 0,
+        x = 0f,
+        y = 0f,
+        width = 100,
+        height = 50,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = Rect(0, 0, 100, 50),
+      )
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, textNode, null)
+
+    assertEquals(1, result.size)
+    renderer.close()
+  }
+
+  @Test
+  fun `renderMasks skips nodes with shouldMask false`() {
+    val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+
+    val rootNode =
+      GenericViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 100,
+        height = 100,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = false,
+        isVisible = true,
+        visibleRect = Rect(0, 0, 100, 100),
+      )
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, rootNode, null)
+
+    assertTrue(result.isEmpty())
+    renderer.close()
+  }
+
+  @Test
+  fun `renderMasks skips nodes with zero dimensions`() {
+    val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+
+    val rootNode =
+      GenericViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 0,
+        height = 0,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = Rect(0, 0, 0, 0),
+      )
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, rootNode, null)
+
+    assertTrue(result.isEmpty())
+    renderer.close()
+  }
+
+  @Test
+  fun `renderMasks skips nodes with null visibleRect`() {
+    val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+
+    val rootNode =
+      GenericViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 100,
+        height = 100,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = null,
+      )
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, rootNode, null)
+
+    assertTrue(result.isEmpty())
+    renderer.close()
+  }
+
+  @Test
+  fun `renderMasks applies scale matrix when provided`() {
+    val bitmap = Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888)
+    bitmap.eraseColor(Color.WHITE)
+
+    val rootNode =
+      GenericViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 100,
+        height = 100,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = Rect(0, 0, 100, 100),
+      )
+
+    val scaleMatrix = Matrix().apply { preScale(0.5f, 0.5f) }
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, rootNode, scaleMatrix)
+
+    assertEquals(1, result.size)
+    renderer.close()
+  }
+
+  @Test
+  fun `renderMasks traverses child nodes`() {
+    val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+    bitmap.eraseColor(Color.WHITE)
+
+    val childNode =
+      GenericViewHierarchyNode(
+        x = 10f,
+        y = 10f,
+        width = 30,
+        height = 30,
+        elevation = 0f,
+        distance = 1,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = Rect(10, 10, 40, 40),
+      )
+
+    val rootNode =
+      GenericViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 100,
+        height = 100,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = false,
+        isVisible = true,
+        visibleRect = Rect(0, 0, 100, 100),
+      )
+    rootNode.children = listOf(childNode)
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, rootNode, null)
+
+    assertEquals(1, result.size)
+    assertEquals(Rect(10, 10, 40, 40), result[0])
+    renderer.close()
+  }
+
+  @Test
+  fun `renderMasks masks multiple nodes`() {
+    val bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+    bitmap.eraseColor(Color.WHITE)
+
+    val child1 =
+      GenericViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 40,
+        height = 40,
+        elevation = 0f,
+        distance = 1,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = Rect(0, 0, 40, 40),
+      )
+
+    val child2 =
+      GenericViewHierarchyNode(
+        x = 50f,
+        y = 50f,
+        width = 40,
+        height = 40,
+        elevation = 0f,
+        distance = 2,
+        shouldMask = true,
+        isVisible = true,
+        visibleRect = Rect(50, 50, 90, 90),
+      )
+
+    val rootNode =
+      GenericViewHierarchyNode(
+        x = 0f,
+        y = 0f,
+        width = 100,
+        height = 100,
+        elevation = 0f,
+        distance = 0,
+        shouldMask = false,
+        isVisible = true,
+        visibleRect = Rect(0, 0, 100, 100),
+      )
+    rootNode.children = listOf(child1, child2)
+
+    val renderer = MaskRenderer()
+    val result = renderer.renderMasks(bitmap, rootNode, null)
+
+    assertEquals(2, result.size)
+    renderer.close()
+  }
+
+  @Test
+  fun `close recycles internal bitmap`() {
+    val renderer = MaskRenderer()
+    // Trigger lazy initialization
+    renderer.singlePixelBitmap
+
+    renderer.close()
+    assertTrue(renderer.singlePixelBitmap.isRecycled)
+  }
+}
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/TextViewDominantColorTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/TextViewDominantColorTest.kt
index 44383330f1e..bdbf31aea1e 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/TextViewDominantColorTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/TextViewDominantColorTest.kt
@@ -33,7 +33,13 @@ class TextViewDominantColorTest {
 
     TextViewActivity.textView?.setTextColor(Color.WHITE)
 
-    val node = ViewHierarchyNode.fromView(TextViewActivity.textView!!, null, 0, SentryOptions())
+    val node =
+      ViewHierarchyNode.fromView(
+        TextViewActivity.textView!!,
+        null,
+        0,
+        SentryOptions().sessionReplay,
+      )
     assertTrue(node is TextViewHierarchyNode)
     assertNull(node.layout?.dominantTextColor)
   }
@@ -53,7 +59,13 @@ class TextViewDominantColorTest {
 
     shadowOf(Looper.getMainLooper()).idle()
 
-    val node = ViewHierarchyNode.fromView(TextViewActivity.textView!!, null, 0, SentryOptions())
+    val node =
+      ViewHierarchyNode.fromView(
+        TextViewActivity.textView!!,
+        null,
+        0,
+        SentryOptions().sessionReplay,
+      )
     assertTrue(node is TextViewHierarchyNode)
     assertEquals(Color.RED, node.layout?.dominantTextColor)
   }
@@ -74,7 +86,13 @@ class TextViewDominantColorTest {
 
     shadowOf(Looper.getMainLooper()).idle()
 
-    val node = ViewHierarchyNode.fromView(TextViewActivity.textView!!, null, 0, SentryOptions())
+    val node =
+      ViewHierarchyNode.fromView(
+        TextViewActivity.textView!!,
+        null,
+        0,
+        SentryOptions().sessionReplay,
+      )
     assertTrue(node is TextViewHierarchyNode)
     assertEquals(Color.BLACK, node.layout?.dominantTextColor)
   }
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
index f3483057a7f..801c8b6e12b 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
@@ -32,6 +32,7 @@ import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import coil.compose.AsyncImage
+import io.sentry.NoOpLogger
 import io.sentry.SentryOptions
 import io.sentry.android.replay.maskAllImages
 import io.sentry.android.replay.maskAllText
@@ -161,7 +162,12 @@ class ComposeMaskingOptionsTest {
       assertNotNull(composeView)
 
       val rootNode = GenericViewHierarchyNode(0f, 0f, 0, 0, 1.0f, -1, shouldMask = true)
-      ComposeViewHierarchyNode.fromView(composeView, rootNode, options)
+      ComposeViewHierarchyNode.fromView(
+        composeView,
+        rootNode,
+        options.sessionReplay,
+        NoOpLogger.getInstance(),
+      )
 
       assertEquals(1, rootNode.children?.size)
 
@@ -275,8 +281,8 @@ class ComposeMaskingOptionsTest {
 
   private inline fun <reified T> Activity.collectNodesOfType(options: SentryOptions): List<T> {
     val root = window.decorView
-    val viewHierarchy = ViewHierarchyNode.fromView(root, null, 0, options)
-    root.traverse(viewHierarchy, options)
+    val viewHierarchy = ViewHierarchyNode.fromView(root, null, 0, options.sessionReplay)
+    root.traverse(viewHierarchy, options.sessionReplay, NoOpLogger.getInstance())
 
     val nodes = mutableListOf<T>()
     viewHierarchy.traverse {
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ContainerMaskingOptionsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ContainerMaskingOptionsTest.kt
index ae9915cf42c..5d5304555ce 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ContainerMaskingOptionsTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ContainerMaskingOptionsTest.kt
@@ -43,7 +43,12 @@ class ContainerMaskingOptionsTest {
       }
 
     val textNode =
-      ViewHierarchyNode.fromView(MaskingOptionsActivity.textViewInUnmask!!, null, 0, options)
+      ViewHierarchyNode.fromView(
+        MaskingOptionsActivity.textViewInUnmask!!,
+        null,
+        0,
+        options.sessionReplay,
+      )
     assertFalse(textNode.shouldMask)
   }
 
@@ -58,7 +63,12 @@ class ContainerMaskingOptionsTest {
       }
 
     val imageNode =
-      ViewHierarchyNode.fromView(MaskingOptionsActivity.imageViewInUnmask!!, null, 0, options)
+      ViewHierarchyNode.fromView(
+        MaskingOptionsActivity.imageViewInUnmask!!,
+        null,
+        0,
+        options.sessionReplay,
+      )
     assertFalse(imageNode.shouldMask)
   }
 
@@ -70,7 +80,12 @@ class ContainerMaskingOptionsTest {
       SentryOptions().apply { sessionReplay.setMaskViewContainerClass(CustomMask::class.java.name) }
 
     val maskContainer =
-      ViewHierarchyNode.fromView(MaskingOptionsActivity.maskWithChildren!!, null, 0, options)
+      ViewHierarchyNode.fromView(
+        MaskingOptionsActivity.maskWithChildren!!,
+        null,
+        0,
+        options.sessionReplay,
+      )
 
     assertTrue(maskContainer.shouldMask)
   }
@@ -86,20 +101,25 @@ class ContainerMaskingOptionsTest {
       }
 
     val maskContainer =
-      ViewHierarchyNode.fromView(MaskingOptionsActivity.unmaskWithChildren!!, null, 0, options)
+      ViewHierarchyNode.fromView(
+        MaskingOptionsActivity.unmaskWithChildren!!,
+        null,
+        0,
+        options.sessionReplay,
+      )
     val firstChild =
       ViewHierarchyNode.fromView(
         MaskingOptionsActivity.customViewInUnmask!!,
         maskContainer,
         0,
-        options,
+        options.sessionReplay,
       )
     val secondLevelChild =
       ViewHierarchyNode.fromView(
         MaskingOptionsActivity.secondLayerChildInUnmask!!,
         firstChild,
         0,
-        options,
+        options.sessionReplay,
       )
 
     assertFalse(maskContainer.shouldMask)
@@ -118,13 +138,18 @@ class ContainerMaskingOptionsTest {
       }
 
     val unmaskNode =
-      ViewHierarchyNode.fromView(MaskingOptionsActivity.unmaskWithMaskChild!!, null, 0, options)
+      ViewHierarchyNode.fromView(
+        MaskingOptionsActivity.unmaskWithMaskChild!!,
+        null,
+        0,
+        options.sessionReplay,
+      )
     val maskNode =
       ViewHierarchyNode.fromView(
         MaskingOptionsActivity.maskAsDirectChildOfUnmask!!,
         unmaskNode,
         0,
-        options,
+        options.sessionReplay,
       )
 
     assertFalse(unmaskNode.shouldMask)
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/MaskingOptionsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/MaskingOptionsTest.kt
index 87543555243..134359aeebe 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/MaskingOptionsTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/MaskingOptionsTest.kt
@@ -46,9 +46,15 @@ class MaskingOptionsTest {
 
     val options = SentryOptions().apply { sessionReplay.maskAllText = true }
 
-    val textNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options)
+    val textNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options.sessionReplay)
     val radioButtonNode =
-      ViewHierarchyNode.fromView(MaskingOptionsActivity.radioButton!!, null, 0, options)
+      ViewHierarchyNode.fromView(
+        MaskingOptionsActivity.radioButton!!,
+        null,
+        0,
+        options.sessionReplay,
+      )
 
     assertTrue(textNode is TextViewHierarchyNode)
     assertTrue(textNode.shouldMask)
@@ -64,9 +70,15 @@ class MaskingOptionsTest {
 
     val options = SentryOptions().apply { sessionReplay.maskAllText = false }
 
-    val textNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options)
+    val textNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options.sessionReplay)
     val radioButtonNode =
-      ViewHierarchyNode.fromView(MaskingOptionsActivity.radioButton!!, null, 0, options)
+      ViewHierarchyNode.fromView(
+        MaskingOptionsActivity.radioButton!!,
+        null,
+        0,
+        options.sessionReplay,
+      )
 
     assertTrue(textNode is TextViewHierarchyNode)
     assertFalse(textNode.shouldMask)
@@ -82,7 +94,8 @@ class MaskingOptionsTest {
 
     val options = SentryOptions().apply { sessionReplay.maskAllImages = true }
 
-    val imageNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.imageView!!, null, 0, options)
+    val imageNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.imageView!!, null, 0, options.sessionReplay)
 
     assertTrue(imageNode is ImageViewHierarchyNode)
     assertTrue(imageNode.shouldMask)
@@ -95,7 +108,8 @@ class MaskingOptionsTest {
 
     val options = SentryOptions().apply { sessionReplay.maskAllImages = false }
 
-    val imageNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.imageView!!, null, 0, options)
+    val imageNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.imageView!!, null, 0, options.sessionReplay)
 
     assertTrue(imageNode is ImageViewHierarchyNode)
     assertFalse(imageNode.shouldMask)
@@ -109,7 +123,8 @@ class MaskingOptionsTest {
     val options = SentryOptions().apply { sessionReplay.maskAllText = false }
 
     MaskingOptionsActivity.textView!!.tag = "sentry-mask"
-    val textNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options)
+    val textNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options.sessionReplay)
 
     assertTrue(textNode.shouldMask)
   }
@@ -122,7 +137,8 @@ class MaskingOptionsTest {
     val options = SentryOptions().apply { sessionReplay.maskAllText = true }
 
     MaskingOptionsActivity.textView!!.tag = "sentry-unmask"
-    val textNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options)
+    val textNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options.sessionReplay)
 
     assertFalse(textNode.shouldMask)
   }
@@ -135,7 +151,8 @@ class MaskingOptionsTest {
     val options = SentryOptions().apply { sessionReplay.maskAllText = false }
 
     MaskingOptionsActivity.textView!!.sentryReplayMask()
-    val textNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options)
+    val textNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options.sessionReplay)
 
     assertTrue(textNode.shouldMask)
   }
@@ -148,7 +165,8 @@ class MaskingOptionsTest {
     val options = SentryOptions().apply { sessionReplay.maskAllText = true }
 
     MaskingOptionsActivity.textView!!.sentryReplayUnmask()
-    val textNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options)
+    val textNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options.sessionReplay)
 
     assertFalse(textNode.shouldMask)
   }
@@ -161,7 +179,8 @@ class MaskingOptionsTest {
     val options = SentryOptions().apply { sessionReplay.maskAllText = true }
 
     MaskingOptionsActivity.textView!!.visibility = View.GONE
-    val textNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options)
+    val textNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options.sessionReplay)
 
     assertFalse(textNode.shouldMask)
   }
@@ -177,7 +196,12 @@ class MaskingOptionsTest {
       }
 
     val customViewNode =
-      ViewHierarchyNode.fromView(MaskingOptionsActivity.customView!!, null, 0, options)
+      ViewHierarchyNode.fromView(
+        MaskingOptionsActivity.customView!!,
+        null,
+        0,
+        options.sessionReplay,
+      )
 
     assertTrue(customViewNode.shouldMask)
   }
@@ -193,9 +217,15 @@ class MaskingOptionsTest {
         sessionReplay.unmaskViewClasses.add(RadioButton::class.java.canonicalName)
       }
 
-    val textNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options)
+    val textNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options.sessionReplay)
     val radioButtonNode =
-      ViewHierarchyNode.fromView(MaskingOptionsActivity.radioButton!!, null, 0, options)
+      ViewHierarchyNode.fromView(
+        MaskingOptionsActivity.radioButton!!,
+        null,
+        0,
+        options.sessionReplay,
+      )
 
     assertTrue(textNode.shouldMask)
     assertFalse(radioButtonNode.shouldMask)
@@ -216,10 +246,12 @@ class MaskingOptionsTest {
         MaskingOptionsActivity.textView!!.parent as LinearLayout,
         null,
         0,
-        options,
+        options.sessionReplay,
       )
-    val textNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options)
-    val imageNode = ViewHierarchyNode.fromView(MaskingOptionsActivity.imageView!!, null, 0, options)
+    val textNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.textView!!, null, 0, options.sessionReplay)
+    val imageNode =
+      ViewHierarchyNode.fromView(MaskingOptionsActivity.imageView!!, null, 0, options.sessionReplay)
 
     assertFalse(linearLayoutNode.shouldMask)
     assertTrue(textNode.shouldMask)
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 0acecb4ccf3..690401e44e3 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -256,7 +256,13 @@
     <meta-data 
       android:name="io.sentry.spotlight.enable"
       android:value="true" />
-    <meta-data 
+    <meta-data
+      android:name="io.sentry.screenshot.mask-all-text"
+      android:value="true" />
+    <meta-data
+      android:name="io.sentry.screenshot.mask-all-images"
+      android:value="true" />
+    <meta-data
       android:name="io.sentry.tombstone.enable"
       android:value="true" />
   </application>
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index a043f8fe85c..4399b191d21 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -3348,6 +3348,33 @@ public final class io/sentry/SentryLongDate : io/sentry/SentryDate {
 	public fun nanoTimestamp ()J
 }
 
+public abstract class io/sentry/SentryMaskingOptions {
+	public static final field ANDROIDX_MEDIA_VIEW_CLASS_NAME Ljava/lang/String;
+	public static final field CAMERAX_PREVIEW_VIEW_CLASS_NAME Ljava/lang/String;
+	public static final field EXOPLAYER_CLASS_NAME Ljava/lang/String;
+	public static final field EXOPLAYER_STYLED_CLASS_NAME Ljava/lang/String;
+	public static final field IMAGE_VIEW_CLASS_NAME Ljava/lang/String;
+	public static final field TEXT_VIEW_CLASS_NAME Ljava/lang/String;
+	public static final field VIDEO_VIEW_CLASS_NAME Ljava/lang/String;
+	public static final field WEB_VIEW_CLASS_NAME Ljava/lang/String;
+	protected field maskViewClasses Ljava/util/Set;
+	protected field maskViewContainerClass Ljava/lang/String;
+	protected field unmaskViewClasses Ljava/util/Set;
+	protected field unmaskViewContainerClass Ljava/lang/String;
+	public fun <init> ()V
+	public fun addMaskViewClass (Ljava/lang/String;)V
+	public fun addUnmaskViewClass (Ljava/lang/String;)V
+	public fun getMaskViewClasses ()Ljava/util/Set;
+	public fun getMaskViewContainerClass ()Ljava/lang/String;
+	public fun getUnmaskViewClasses ()Ljava/util/Set;
+	public fun getUnmaskViewContainerClass ()Ljava/lang/String;
+	public fun setMaskAllImages (Z)V
+	public fun setMaskAllText (Z)V
+	public fun setMaskViewContainerClass (Ljava/lang/String;)V
+	public fun setUnmaskViewContainerClass (Ljava/lang/String;)V
+	public abstract fun trackCustomMasking ()V
+}
+
 public final class io/sentry/SentryMetricsEvent : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
 	public fun <init> (Lio/sentry/protocol/SentryId;Lio/sentry/SentryDate;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Double;)V
 	public fun <init> (Lio/sentry/protocol/SentryId;Ljava/lang/Double;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Double;)V
@@ -3902,24 +3929,14 @@ public final class io/sentry/SentryReplayEvent$ReplayType$Deserializer : io/sent
 	public synthetic fun deserialize (Lio/sentry/ObjectReader;Lio/sentry/ILogger;)Ljava/lang/Object;
 }
 
-public final class io/sentry/SentryReplayOptions {
-	public static final field ANDROIDX_MEDIA_VIEW_CLASS_NAME Ljava/lang/String;
-	public static final field CAMERAX_PREVIEW_VIEW_CLASS_NAME Ljava/lang/String;
-	public static final field EXOPLAYER_CLASS_NAME Ljava/lang/String;
-	public static final field EXOPLAYER_STYLED_CLASS_NAME Ljava/lang/String;
-	public static final field IMAGE_VIEW_CLASS_NAME Ljava/lang/String;
+public final class io/sentry/SentryReplayOptions : io/sentry/SentryMaskingOptions {
 	public static final field MAX_NETWORK_BODY_SIZE I
-	public static final field TEXT_VIEW_CLASS_NAME Ljava/lang/String;
-	public static final field VIDEO_VIEW_CLASS_NAME Ljava/lang/String;
-	public static final field WEB_VIEW_CLASS_NAME Ljava/lang/String;
 	public fun <init> (Ljava/lang/Double;Ljava/lang/Double;Lio/sentry/protocol/SdkVersion;)V
 	public fun <init> (ZLio/sentry/protocol/SdkVersion;)V
 	public fun addMaskViewClass (Ljava/lang/String;)V
 	public fun addUnmaskViewClass (Ljava/lang/String;)V
 	public fun getErrorReplayDuration ()J
 	public fun getFrameRate ()I
-	public fun getMaskViewClasses ()Ljava/util/Set;
-	public fun getMaskViewContainerClass ()Ljava/lang/String;
 	public fun getNetworkDetailAllowUrls ()Ljava/util/List;
 	public fun getNetworkDetailDenyUrls ()Ljava/util/List;
 	public static fun getNetworkDetailsDefaultHeaders ()Ljava/util/List;
@@ -3932,8 +3949,6 @@ public final class io/sentry/SentryReplayOptions {
 	public fun getSessionDuration ()J
 	public fun getSessionSampleRate ()Ljava/lang/Double;
 	public fun getSessionSegmentDuration ()J
-	public fun getUnmaskViewClasses ()Ljava/util/Set;
-	public fun getUnmaskViewContainerClass ()Ljava/lang/String;
 	public fun isDebug ()Z
 	public fun isNetworkCaptureBodies ()Z
 	public fun isSessionReplayEnabled ()Z
@@ -3942,7 +3957,6 @@ public final class io/sentry/SentryReplayOptions {
 	public fun setDebug (Z)V
 	public fun setMaskAllImages (Z)V
 	public fun setMaskAllText (Z)V
-	public fun setMaskViewContainerClass (Ljava/lang/String;)V
 	public fun setNetworkCaptureBodies (Z)V
 	public fun setNetworkDetailAllowUrls (Ljava/util/List;)V
 	public fun setNetworkDetailDenyUrls (Ljava/util/List;)V
@@ -3954,7 +3968,6 @@ public final class io/sentry/SentryReplayOptions {
 	public fun setSdkVersion (Lio/sentry/protocol/SdkVersion;)V
 	public fun setSessionSampleRate (Ljava/lang/Double;)V
 	public fun setTrackConfiguration (Z)V
-	public fun setUnmaskViewContainerClass (Ljava/lang/String;)V
 	public fun trackCustomMasking ()V
 }
 
diff --git a/sentry/src/main/java/io/sentry/Scopes.java b/sentry/src/main/java/io/sentry/Scopes.java
index 374ecbfdb55..ee3d55f2291 100644
--- a/sentry/src/main/java/io/sentry/Scopes.java
+++ b/sentry/src/main/java/io/sentry/Scopes.java
@@ -441,6 +441,21 @@ public void close(final boolean isRestarting) {
             }
           }
         }
+        for (EventProcessor eventProcessor : getOptions().getEventProcessors()) {
+          if (eventProcessor instanceof Closeable) {
+            try {
+              ((Closeable) eventProcessor).close();
+            } catch (Throwable e) {
+              getOptions()
+                  .getLogger()
+                  .log(
+                      SentryLevel.WARNING,
+                      "Failed to close the event processor {}.",
+                      eventProcessor,
+                      e);
+            }
+          }
+        }
 
         configureScope(scope -> scope.clear());
         configureScope(ScopeType.ISOLATION, scope -> scope.clear());
diff --git a/sentry/src/main/java/io/sentry/SentryMaskingOptions.java b/sentry/src/main/java/io/sentry/SentryMaskingOptions.java
new file mode 100644
index 00000000000..dd7c5f9a304
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/SentryMaskingOptions.java
@@ -0,0 +1,129 @@
+package io.sentry;
+
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Base class for masking configuration used by both Session Replay and Screenshot features.
+ * Contains common settings for which view classes should be masked or unmasked.
+ */
+public abstract class SentryMaskingOptions {
+
+  public static final String TEXT_VIEW_CLASS_NAME = "android.widget.TextView";
+  public static final String IMAGE_VIEW_CLASS_NAME = "android.widget.ImageView";
+  public static final String WEB_VIEW_CLASS_NAME = "android.webkit.WebView";
+  public static final String VIDEO_VIEW_CLASS_NAME = "android.widget.VideoView";
+  public static final String CAMERAX_PREVIEW_VIEW_CLASS_NAME = "androidx.camera.view.PreviewView";
+  public static final String ANDROIDX_MEDIA_VIEW_CLASS_NAME = "androidx.media3.ui.PlayerView";
+  public static final String EXOPLAYER_CLASS_NAME = "com.google.android.exoplayer2.ui.PlayerView";
+  public static final String EXOPLAYER_STYLED_CLASS_NAME =
+      "com.google.android.exoplayer2.ui.StyledPlayerView";
+
+  /**
+   * Mask all views with the specified class names. The class name is the fully qualified class name
+   * of the view, e.g. android.widget.TextView. The subclasses of the specified classes will be
+   * masked as well.
+   *
+   * <p>If you're using an obfuscation tool, make sure to add the respective proguard rules to keep
+   * the class names.
+   *
+   * <p>Default is empty.
+   */
+  protected Set<String> maskViewClasses = new CopyOnWriteArraySet<>();
+
+  /**
+   * Ignore all views with the specified class names from masking. The class name is the fully
+   * qualified class name of the view, e.g. android.widget.TextView. The subclasses of the specified
+   * classes will be ignored as well.
+   *
+   * <p>If you're using an obfuscation tool, make sure to add the respective proguard rules to keep
+   * the class names.
+   *
+   * <p>Default is empty.
+   */
+  protected Set<String> unmaskViewClasses = new CopyOnWriteArraySet<>();
+
+  /** The class name of the view container that masks all of its children. */
+  protected @Nullable String maskViewContainerClass = null;
+
+  /** The class name of the view container that unmasks its direct children. */
+  protected @Nullable String unmaskViewContainerClass = null;
+
+  /**
+   * Mask all text content. Draws a rectangle of text bounds with text color on top. By default only
+   * views extending TextView are masked.
+   *
+   * <p>Default is enabled.
+   */
+  public void setMaskAllText(final boolean maskAllText) {
+    if (maskAllText) {
+      maskViewClasses.add(TEXT_VIEW_CLASS_NAME);
+      unmaskViewClasses.remove(TEXT_VIEW_CLASS_NAME);
+    } else {
+      unmaskViewClasses.add(TEXT_VIEW_CLASS_NAME);
+      maskViewClasses.remove(TEXT_VIEW_CLASS_NAME);
+    }
+  }
+
+  /**
+   * Mask all image content. Draws a rectangle of image bounds with image's dominant color on top.
+   * By default only views extending ImageView with BitmapDrawable or custom Drawable type are
+   * masked. ColorDrawable, InsetDrawable, VectorDrawable are all considered non-PII, as they come
+   * from the apk.
+   *
+   * <p>Default is enabled.
+   */
+  public void setMaskAllImages(final boolean maskAllImages) {
+    if (maskAllImages) {
+      maskViewClasses.add(IMAGE_VIEW_CLASS_NAME);
+      unmaskViewClasses.remove(IMAGE_VIEW_CLASS_NAME);
+    } else {
+      unmaskViewClasses.add(IMAGE_VIEW_CLASS_NAME);
+      maskViewClasses.remove(IMAGE_VIEW_CLASS_NAME);
+    }
+  }
+
+  @NotNull
+  public Set<String> getMaskViewClasses() {
+    return this.maskViewClasses;
+  }
+
+  public void addMaskViewClass(final @NotNull String className) {
+    this.maskViewClasses.add(className);
+    this.unmaskViewClasses.remove(className);
+  }
+
+  @NotNull
+  public Set<String> getUnmaskViewClasses() {
+    return this.unmaskViewClasses;
+  }
+
+  public void addUnmaskViewClass(final @NotNull String className) {
+    this.unmaskViewClasses.add(className);
+    this.maskViewClasses.remove(className);
+  }
+
+  public @Nullable String getMaskViewContainerClass() {
+    return maskViewContainerClass;
+  }
+
+  public void setMaskViewContainerClass(@NotNull String containerClass) {
+    maskViewClasses.add(containerClass);
+    maskViewContainerClass = containerClass;
+  }
+
+  public @Nullable String getUnmaskViewContainerClass() {
+    return unmaskViewContainerClass;
+  }
+
+  public void setUnmaskViewContainerClass(@NotNull String containerClass) {
+    unmaskViewContainerClass = containerClass;
+  }
+
+  /** Hook for subclasses to track custom masking usage. */
+  @ApiStatus.Internal
+  public abstract void trackCustomMasking();
+}
diff --git a/sentry/src/main/java/io/sentry/SentryReplayOptions.java b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
index cc8733fd824..3c618bfee9d 100644
--- a/sentry/src/main/java/io/sentry/SentryReplayOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
@@ -11,26 +11,15 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Set;
-import java.util.concurrent.CopyOnWriteArraySet;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public final class SentryReplayOptions {
+public final class SentryReplayOptions extends SentryMaskingOptions {
 
   private static final String CUSTOM_MASKING_INTEGRATION_NAME = "ReplayCustomMasking";
   private volatile boolean customMaskingTracked = false;
 
-  public static final String TEXT_VIEW_CLASS_NAME = "android.widget.TextView";
-  public static final String IMAGE_VIEW_CLASS_NAME = "android.widget.ImageView";
-  public static final String WEB_VIEW_CLASS_NAME = "android.webkit.WebView";
-  public static final String VIDEO_VIEW_CLASS_NAME = "android.widget.VideoView";
-  public static final String CAMERAX_PREVIEW_VIEW_CLASS_NAME = "androidx.camera.view.PreviewView";
-  public static final String ANDROIDX_MEDIA_VIEW_CLASS_NAME = "androidx.media3.ui.PlayerView";
-  public static final String EXOPLAYER_CLASS_NAME = "com.google.android.exoplayer2.ui.PlayerView";
-  public static final String EXOPLAYER_STYLED_CLASS_NAME =
-      "com.google.android.exoplayer2.ui.StyledPlayerView";
-
   /**
    * Maximum size in bytes for network request/response bodies to be captured in replays. Bodies
    * larger than this will be truncated or replaced with a placeholder message. Aligned <a
@@ -86,36 +75,6 @@ public enum SentryReplayQuality {
    */
   private @Nullable Double onErrorSampleRate;
 
-  /**
-   * Mask all views with the specified class names. The class name is the fully qualified class name
-   * of the view, e.g. android.widget.TextView. The subclasses of the specified classes will be
-   * masked as well.
-   *
-   * <p>If you're using an obfuscation tool, make sure to add the respective proguard rules to keep
-   * the class names.
-   *
-   * <p>Default is empty.
-   */
-  private Set<String> maskViewClasses = new CopyOnWriteArraySet<>();
-
-  /**
-   * Ignore all views with the specified class names from masking. The class name is the fully
-   * qualified class name of the view, e.g. android.widget.TextView. The subclasses of the specified
-   * classes will be ignored as well.
-   *
-   * <p>If you're using an obfuscation tool, make sure to add the respective proguard rules to keep
-   * the class names.
-   *
-   * <p>Default is empty.
-   */
-  private Set<String> unmaskViewClasses = new CopyOnWriteArraySet<>();
-
-  /** The class name of the view container that masks all of its children. */
-  private @Nullable String maskViewContainerClass = null;
-
-  /** The class name of the view container that unmasks its direct children. */
-  private @Nullable String unmaskViewContainerClass = null;
-
   /**
    * Defines the quality of the session replay. The higher the quality, the more accurate the replay
    * will be, but also more data to transfer and more CPU load, defaults to MEDIUM.
@@ -276,60 +235,32 @@ public void setSessionSampleRate(final @Nullable Double sessionSampleRate) {
     this.sessionSampleRate = sessionSampleRate;
   }
 
-  /**
-   * Mask all text content. Draws a rectangle of text bounds with text color on top. By default only
-   * views extending TextView are masked.
-   *
-   * <p>Default is enabled.
-   */
+  @Override
   public void setMaskAllText(final boolean maskAllText) {
-    if (maskAllText) {
-      maskViewClasses.add(TEXT_VIEW_CLASS_NAME);
-      unmaskViewClasses.remove(TEXT_VIEW_CLASS_NAME);
-    } else {
+    if (!maskAllText) {
       trackCustomMasking();
-      unmaskViewClasses.add(TEXT_VIEW_CLASS_NAME);
-      maskViewClasses.remove(TEXT_VIEW_CLASS_NAME);
     }
+    super.setMaskAllText(maskAllText);
   }
 
-  /**
-   * Mask all image content. Draws a rectangle of image bounds with image's dominant color on top.
-   * By default only views extending ImageView with BitmapDrawable or custom Drawable type are
-   * masked. ColorDrawable, InsetDrawable, VectorDrawable are all considered non-PII, as they come
-   * from the apk.
-   *
-   * <p>Default is enabled.
-   */
+  @Override
   public void setMaskAllImages(final boolean maskAllImages) {
-    if (maskAllImages) {
-      maskViewClasses.add(IMAGE_VIEW_CLASS_NAME);
-      unmaskViewClasses.remove(IMAGE_VIEW_CLASS_NAME);
-    } else {
+    if (!maskAllImages) {
       trackCustomMasking();
-      unmaskViewClasses.add(IMAGE_VIEW_CLASS_NAME);
-      maskViewClasses.remove(IMAGE_VIEW_CLASS_NAME);
     }
+    super.setMaskAllImages(maskAllImages);
   }
 
-  @NotNull
-  public Set<String> getMaskViewClasses() {
-    return this.maskViewClasses;
-  }
-
+  @Override
   public void addMaskViewClass(final @NotNull String className) {
     trackCustomMasking();
-    this.maskViewClasses.add(className);
-  }
-
-  @NotNull
-  public Set<String> getUnmaskViewClasses() {
-    return this.unmaskViewClasses;
+    super.addMaskViewClass(className);
   }
 
+  @Override
   public void addUnmaskViewClass(final @NotNull String className) {
     trackCustomMasking();
-    this.unmaskViewClasses.add(className);
+    super.addUnmaskViewClass(className);
   }
 
   @ApiStatus.Internal
@@ -361,28 +292,7 @@ public long getSessionDuration() {
     return sessionDuration;
   }
 
-  @ApiStatus.Internal
-  public void setMaskViewContainerClass(@NotNull String containerClass) {
-    maskViewClasses.add(containerClass);
-    maskViewContainerClass = containerClass;
-  }
-
-  @ApiStatus.Internal
-  public void setUnmaskViewContainerClass(@NotNull String containerClass) {
-    unmaskViewContainerClass = containerClass;
-  }
-
-  @ApiStatus.Internal
-  public @Nullable String getMaskViewContainerClass() {
-    return maskViewContainerClass;
-  }
-
-  @ApiStatus.Internal
-  public @Nullable String getUnmaskViewContainerClass() {
-    return unmaskViewContainerClass;
-  }
-
-  @ApiStatus.Internal
+  @Override
   public void trackCustomMasking() {
     if (!customMaskingTracked) {
       customMaskingTracked = true;
diff --git a/sentry/src/test/java/io/sentry/SentryMaskingOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryMaskingOptionsTest.kt
new file mode 100644
index 00000000000..9f661710dc7
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/SentryMaskingOptionsTest.kt
@@ -0,0 +1,133 @@
+package io.sentry
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class SentryMaskingOptionsTest {
+
+  private class TestMaskingOptions : SentryMaskingOptions() {
+    override fun trackCustomMasking() {
+      // no-op for tests
+    }
+  }
+
+  @Test
+  fun `maskViewClasses is empty by default`() {
+    val options = TestMaskingOptions()
+    assertTrue(options.maskViewClasses.isEmpty())
+  }
+
+  @Test
+  fun `unmaskViewClasses is empty by default`() {
+    val options = TestMaskingOptions()
+    assertTrue(options.unmaskViewClasses.isEmpty())
+  }
+
+  @Test
+  fun `addMaskViewClass adds class to set`() {
+    val options = TestMaskingOptions()
+    options.addMaskViewClass("com.example.MyView")
+    assertTrue(options.maskViewClasses.contains("com.example.MyView"))
+  }
+
+  @Test
+  fun `addUnmaskViewClass adds class to set`() {
+    val options = TestMaskingOptions()
+    options.addUnmaskViewClass("com.example.MyView")
+    assertTrue(options.unmaskViewClasses.contains("com.example.MyView"))
+  }
+
+  @Test
+  fun `setMaskAllText true adds TextView to maskViewClasses`() {
+    val options = TestMaskingOptions()
+    options.setMaskAllText(true)
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.TEXT_VIEW_CLASS_NAME))
+    assertFalse(options.unmaskViewClasses.contains(SentryMaskingOptions.TEXT_VIEW_CLASS_NAME))
+  }
+
+  @Test
+  fun `setMaskAllText false adds TextView to unmaskViewClasses`() {
+    val options = TestMaskingOptions()
+    options.setMaskAllText(false)
+    assertTrue(options.unmaskViewClasses.contains(SentryMaskingOptions.TEXT_VIEW_CLASS_NAME))
+    assertFalse(options.maskViewClasses.contains(SentryMaskingOptions.TEXT_VIEW_CLASS_NAME))
+  }
+
+  @Test
+  fun `setMaskAllText true removes TextView from unmaskViewClasses`() {
+    val options = TestMaskingOptions()
+    options.addUnmaskViewClass(SentryMaskingOptions.TEXT_VIEW_CLASS_NAME)
+    options.setMaskAllText(true)
+    assertFalse(options.unmaskViewClasses.contains(SentryMaskingOptions.TEXT_VIEW_CLASS_NAME))
+  }
+
+  @Test
+  fun `setMaskAllText false removes TextView from maskViewClasses`() {
+    val options = TestMaskingOptions()
+    options.addMaskViewClass(SentryMaskingOptions.TEXT_VIEW_CLASS_NAME)
+    options.setMaskAllText(false)
+    assertFalse(options.maskViewClasses.contains(SentryMaskingOptions.TEXT_VIEW_CLASS_NAME))
+  }
+
+  @Test
+  fun `setMaskAllImages true adds ImageView to maskViewClasses`() {
+    val options = TestMaskingOptions()
+    options.setMaskAllImages(true)
+    assertTrue(options.maskViewClasses.contains(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME))
+    assertFalse(options.unmaskViewClasses.contains(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME))
+  }
+
+  @Test
+  fun `setMaskAllImages false adds ImageView to unmaskViewClasses`() {
+    val options = TestMaskingOptions()
+    options.setMaskAllImages(false)
+    assertTrue(options.unmaskViewClasses.contains(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME))
+    assertFalse(options.maskViewClasses.contains(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME))
+  }
+
+  @Test
+  fun `setMaskAllImages true removes ImageView from unmaskViewClasses`() {
+    val options = TestMaskingOptions()
+    options.addUnmaskViewClass(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME)
+    options.setMaskAllImages(true)
+    assertFalse(options.unmaskViewClasses.contains(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME))
+  }
+
+  @Test
+  fun `setMaskAllImages false removes ImageView from maskViewClasses`() {
+    val options = TestMaskingOptions()
+    options.addMaskViewClass(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME)
+    options.setMaskAllImages(false)
+    assertFalse(options.maskViewClasses.contains(SentryMaskingOptions.IMAGE_VIEW_CLASS_NAME))
+  }
+
+  @Test
+  fun `maskViewContainerClass is null by default`() {
+    val options = TestMaskingOptions()
+    assertNull(options.maskViewContainerClass)
+  }
+
+  @Test
+  fun `unmaskViewContainerClass is null by default`() {
+    val options = TestMaskingOptions()
+    assertNull(options.unmaskViewContainerClass)
+  }
+
+  @Test
+  fun `setMaskViewContainerClass sets container and adds to maskViewClasses`() {
+    val options = TestMaskingOptions()
+    options.setMaskViewContainerClass("com.example.Container")
+    assertEquals("com.example.Container", options.maskViewContainerClass)
+    assertTrue(options.maskViewClasses.contains("com.example.Container"))
+  }
+
+  @Test
+  fun `setUnmaskViewContainerClass sets container`() {
+    val options = TestMaskingOptions()
+    options.setUnmaskViewContainerClass("com.example.Container")
+    assertEquals("com.example.Container", options.unmaskViewContainerClass)
+  }
+}

From 8f80cf43e0e83b9a3dc18f09ffa6e24606f12944 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Fri, 27 Feb 2026 13:06:28 +0100
Subject: [PATCH 009/391] fix(test): Fix flaky tests caused by
 SentryOptions.activate overriding executor service (#5125)

Use NonOverridableNoOpSentryExecutorService instead of NoOpSentryExecutorService.getInstance()
in tests, since the latter is a sentinel value that gets replaced during activate().

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 sentry-test-support/api/sentry-test-support.api   | 10 ++++++++++
 .../src/main/kotlin/io/sentry/test/Mocks.kt       | 15 +++++++++++++++
 sentry/src/test/java/io/sentry/SentryTest.kt      |  5 +++--
 3 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/sentry-test-support/api/sentry-test-support.api b/sentry-test-support/api/sentry-test-support.api
index 8bfaaeefef1..1d8ae671216 100644
--- a/sentry-test-support/api/sentry-test-support.api
+++ b/sentry-test-support/api/sentry-test-support.api
@@ -55,6 +55,16 @@ public final class io/sentry/test/MocksKt {
 	public static synthetic fun createTestScopes$default (Lio/sentry/SentryOptions;ZLio/sentry/IScope;Lio/sentry/IScope;Lio/sentry/IScope;ILjava/lang/Object;)Lio/sentry/Scopes;
 }
 
+public final class io/sentry/test/NonOverridableNoOpSentryExecutorService : io/sentry/ISentryExecutorService {
+	public fun <init> ()V
+	public fun close (J)V
+	public fun isClosed ()Z
+	public fun prewarm ()V
+	public fun schedule (Ljava/lang/Runnable;J)Ljava/util/concurrent/Future;
+	public fun submit (Ljava/lang/Runnable;)Ljava/util/concurrent/Future;
+	public fun submit (Ljava/util/concurrent/Callable;)Ljava/util/concurrent/Future;
+}
+
 public final class io/sentry/test/ReflectionKt {
 	public static final fun collectInterfaceHierarchy (Ljava/lang/Class;)Ljava/util/List;
 	public static final fun containsMethod (Ljava/lang/Class;Ljava/lang/String;Ljava/lang/Class;)Z
diff --git a/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt b/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt
index 09d5d181ec4..da69b7cf330 100644
--- a/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt
+++ b/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt
@@ -79,6 +79,21 @@ class DeferredExecutorService : ISentryExecutorService {
   fun hasScheduledRunnables(): Boolean = scheduledRunnables.isNotEmpty()
 }
 
+class NonOverridableNoOpSentryExecutorService : ISentryExecutorService {
+  override fun submit(runnable: Runnable): Future<*> = FutureTask<Void> { null }
+
+  override fun <T> submit(callable: Callable<T>): Future<T> = FutureTask<T> { null }
+
+  override fun schedule(runnable: Runnable, delayMillis: Long): Future<*> =
+    FutureTask<Void> { null }
+
+  override fun close(timeoutMillis: Long) {}
+
+  override fun isClosed(): Boolean = false
+
+  override fun prewarm() = Unit
+}
+
 fun createSentryClientMock(enabled: Boolean = true) =
   mock<ISentryClient>().also {
     val isEnabled = AtomicBoolean(enabled)
diff --git a/sentry/src/test/java/io/sentry/SentryTest.kt b/sentry/src/test/java/io/sentry/SentryTest.kt
index c94375735d2..72febe35665 100644
--- a/sentry/src/test/java/io/sentry/SentryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTest.kt
@@ -17,6 +17,7 @@ import io.sentry.protocol.SdkVersion
 import io.sentry.protocol.SentryId
 import io.sentry.protocol.SentryThread
 import io.sentry.test.ImmediateExecutorService
+import io.sentry.test.NonOverridableNoOpSentryExecutorService
 import io.sentry.test.createSentryClientMock
 import io.sentry.test.initForTest
 import io.sentry.test.injectForField
@@ -1217,7 +1218,7 @@ class SentryTest {
       it.profilesSampleRate = 1.0
       it.tracesSampler = mockSampleTracer
       it.profilesSampler = mockProfilesSampler
-      it.executorService = NoOpSentryExecutorService.getInstance()
+      it.executorService = NonOverridableNoOpSentryExecutorService()
       it.cacheDirPath = getTempPath()
     }
     // Samplers are called with isForNextAppStart flag set to true
@@ -1236,7 +1237,7 @@ class SentryTest {
       it.profilesSampleRate = 1.0
       it.tracesSampler = mockSampleTracer
       it.profilesSampler = mockProfilesSampler
-      it.executorService = NoOpSentryExecutorService.getInstance()
+      it.executorService = NonOverridableNoOpSentryExecutorService()
       it.cacheDirPath = null
     }
     // Samplers are called with isForNextAppStart flag set to true

From 9dc12d16737ed80920af98e3be081edcbf7c99b6 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Fri, 27 Feb 2026 13:46:14 +0100
Subject: [PATCH 010/391] fix(test): Fix flaky MainEventProcessorTest by
 checking crashed thread (#5126)

Assert stacktrace on the crashed thread instead of the first thread in
the list, which may not be the crashed one depending on thread ordering.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 sentry/src/test/java/io/sentry/MainEventProcessorTest.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt b/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
index 6fc2c8c243b..229fd571871 100644
--- a/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
+++ b/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
@@ -258,7 +258,7 @@ class MainEventProcessorTest {
 
     assertNotNull(event.threads)
     assertEquals(1, event.threads!!.count { it.isCrashed == true })
-    assertNotNull(event.threads!!.first().stacktrace)
+    assertNotNull(event.threads!!.first { it.isCrashed == true }.stacktrace)
   }
 
   @Test

From 6c03ee914c096859c7dc72cdeef0265ce28793ac Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Fri, 27 Feb 2026 17:02:46 +0100
Subject: [PATCH 011/391] feat(otel): Create `sentry-opentelemetry-otlp` module
 for combining OpenTelemetry SDK OTLP export with Sentry SDK (#5100)

* Create sentry-opentelemetry-otlp module and OTLP sample for Spring Boot 4

* Format code

* also set trace id and span id for logs and metrics

* Format code

* add console otlp sample; some missing things; cleanup

* simplify usage by adding an SPI file and propagator provider class

* changelog

* adapt test to modifications from original console sample

* add otel dependencies to otlp module so it is easier to use

* add sentry-opentelemetry-otlp-spring module

* update changelog

* read sentry-trace header for sampled / non sampled TraceFlags

* update opentelemetry.mdc to mention otlp-spring module

* convert to api dependencies

* only add baggage to context if actually present

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 .craft.yml                                    |   2 +
 .cursor/rules/opentelemetry.mdc               |   9 +
 .github/workflows/system-tests-backend.yml    |   6 +
 CHANGELOG.md                                  |   4 +
 README.md                                     |   2 +
 build.gradle.kts                              |   4 +-
 buildSrc/src/main/java/Config.kt              |   2 +
 gradle/libs.versions.toml                     |   2 +
 .../README.md                                 |   7 +
 .../build.gradle.kts                          |  22 ++
 .../sentry-opentelemetry-otlp/README.md       |   7 +
 .../api/sentry-opentelemetry-otlp.api         |  22 ++
 .../build.gradle.kts                          |  84 ++++++
 .../otlp/OpenTelemetryOtlpEventProcessor.java | 120 +++++++++
 .../otlp/OpenTelemetryOtlpPropagator.java     | 129 +++++++++
 .../OpenTelemetryOtlpPropagatorProvider.java  |  17 ++
 ...nfigure.spi.ConfigurablePropagatorProvider |   1 +
 .../test/kotlin/OtelSentryPropagatorTest.kt   | 184 +++++++++++++
 .../sentry-samples-console-otlp/README.md     |  13 +
 .../api/sentry-samples-console-otlp.api       |   5 +
 .../build.gradle.kts                          |  87 +++++++
 .../java/io/sentry/samples/console/Main.java  | 244 ++++++++++++++++++
 .../src/test/kotlin/io/sentry/DummyTest.kt    |  12 +
 .../ConsoleApplicationSystemTest.kt           | 107 ++++++++
 .../README.md                                 | 122 +++++++++
 .../build.gradle.kts                          | 101 ++++++++
 .../boot4/otlp/CustomEventProcessor.java      |  35 +++
 .../samples/spring/boot4/otlp/CustomJob.java  |  25 ++
 .../otlp/DistributedTracingController.java    |  49 ++++
 .../spring/boot4/otlp/MetricController.java   |  35 +++
 .../samples/spring/boot4/otlp/Person.java     |  24 ++
 .../spring/boot4/otlp/PersonController.java   |  51 ++++
 .../spring/boot4/otlp/PersonService.java      |  41 +++
 .../boot4/otlp/SecurityConfiguration.java     |  41 +++
 .../boot4/otlp/SentryDemoApplication.java     |  81 ++++++
 .../samples/spring/boot4/otlp/Todo.java       |  25 ++
 .../spring/boot4/otlp/TodoController.java     |  57 ++++
 .../otlp/graphql/AssigneeController.java      |  34 +++
 .../otlp/graphql/GreetingController.java      |  17 ++
 .../boot4/otlp/graphql/ProjectController.java | 140 ++++++++++
 .../otlp/graphql/TaskCreatorController.java   |  50 ++++
 .../spring/boot4/otlp/quartz/SampleJob.java   |  19 ++
 .../src/main/resources/application.properties |  53 ++++
 .../main/resources/graphql/schema.graphqls    |  68 +++++
 .../src/main/resources/quartz.properties      |   1 +
 .../src/main/resources/schema.sql             |   5 +
 .../src/test/kotlin/io/sentry/DummyTest.kt    |  12 +
 .../DistributedTracingSystemTest.kt           | 197 ++++++++++++++
 .../systemtest/GraphqlGreetingSystemTest.kt   |  46 ++++
 .../systemtest/GraphqlProjectSystemTest.kt    |  66 +++++
 .../systemtest/GraphqlTaskSystemTest.kt       |  50 ++++
 .../io/sentry/systemtest/MetricsSystemTest.kt |  49 ++++
 .../io/sentry/systemtest/PersonSystemTest.kt  |  96 +++++++
 .../io/sentry/systemtest/TodoSystemTest.kt    |  61 +++++
 .../src/test/resources/logback.xml            |  17 ++
 settings.gradle.kts                           |   4 +
 test/system-test-runner.py                    |   2 +
 57 files changed, 2765 insertions(+), 1 deletion(-)
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp-spring/README.md
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp-spring/build.gradle.kts
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp/README.md
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp/api/sentry-opentelemetry-otlp.api
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpEventProcessor.java
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagatorProvider.java
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ConfigurablePropagatorProvider
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt
 create mode 100644 sentry-samples/sentry-samples-console-otlp/README.md
 create mode 100644 sentry-samples/sentry-samples-console-otlp/api/sentry-samples-console-otlp.api
 create mode 100644 sentry-samples/sentry-samples-console-otlp/build.gradle.kts
 create mode 100644 sentry-samples/sentry-samples-console-otlp/src/main/java/io/sentry/samples/console/Main.java
 create mode 100644 sentry-samples/sentry-samples-console-otlp/src/test/kotlin/io/sentry/DummyTest.kt
 create mode 100644 sentry-samples/sentry-samples-console-otlp/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/README.md
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CustomEventProcessor.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CustomJob.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/DistributedTracingController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/MetricController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/Person.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/PersonController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/PersonService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SecurityConfiguration.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SentryDemoApplication.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/Todo.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/TodoController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/AssigneeController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/GreetingController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/ProjectController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/TaskCreatorController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/quartz/SampleJob.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/application.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/graphql/schema.graphqls
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/quartz.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/schema.sql
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/DummyTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/DistributedTracingSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlGreetingSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlProjectSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlTaskSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/TodoSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/resources/logback.xml

diff --git a/.craft.yml b/.craft.yml
index 6f52255dd63..cb52926ad56 100644
--- a/.craft.yml
+++ b/.craft.yml
@@ -48,6 +48,8 @@ targets:
       maven:io.sentry:sentry-opentelemetry-agentless-spring:
       maven:io.sentry:sentry-opentelemetry-bootstrap:
       maven:io.sentry:sentry-opentelemetry-core:
+#      maven:io.sentry:sentry-opentelemetry-otlp:
+#      maven:io.sentry:sentry-opentelemetry-otlp-spring:
       maven:io.sentry:sentry-apollo:
       maven:io.sentry:sentry-jdbc:
       maven:io.sentry:sentry-graphql:
diff --git a/.cursor/rules/opentelemetry.mdc b/.cursor/rules/opentelemetry.mdc
index 7a94dcf58f4..4e773233f04 100644
--- a/.cursor/rules/opentelemetry.mdc
+++ b/.cursor/rules/opentelemetry.mdc
@@ -14,6 +14,8 @@ The Sentry Java SDK provides comprehensive OpenTelemetry integration through mul
 - `sentry-opentelemetry-agentless-spring`: Spring-specific agentless integration
 - `sentry-opentelemetry-bootstrap`: Classes that go into the bootstrap classloader when the agent is used. For agentless they are simply used in the applications classloader.
 - `sentry-opentelemetry-agentcustomization`: Classes that help wire up Sentry in OpenTelemetry. These land in the agent classloader when the agent is used. For agentless they are simply used in the application classloader.
+- `sentry-opentelemetry-otlp`: Classes for using OpenTelemetry to send spans to Sentry using the OTLP endpoint and have Sentry use OpenTelemetry trace and span id.
+- `sentry-opentelemetry-otlp-spring`: Spring Boot convenience module that includes `sentry-opentelemetry-otlp` and the OpenTelemetry Spring Boot starter as transitive dependencies.
 
 ## Advantages over using Sentry without OpenTelemetry
 
@@ -86,3 +88,10 @@ After creating the transaction with child spans `SentrySpanExporter` uses Sentry
 ## Troubleshooting
 
 To debug forking of `Scopes`, we added a reference to `parent` `Scopes` and a `creator` String to store the reason why `Scopes` were created or forked.
+
+# OTLP
+When using `sentry-opentelemetry-otlp`, Sentry only loads trace ID and span ID from OpenTelemetry `Context` (via `OpenTelemetryOtlpEventProcessor`). Sentry does not rely on OpenTelemetry `Context` for scope storage and propagation, instead relying on its `DefaultScopesStorage`.
+It is common to keep Performance in Sentry SDK disabled since that part is taken over by OpenTelemetry.
+The `sentry-opentelemetry-otlp` module is not connected to the other `sentry-opentelemetry-*` modules but instead intended only when the goal is to run OpenTelemetry for creating spans and Sentry for other products like errors, logs, metrics etc.
+The `sentry-opentelemetry-otlp-spring` module wraps `sentry-opentelemetry-otlp` and includes the OpenTelemetry Spring Boot starter for easier setup in Spring Boot applications.
+The OTLP module does not easily work with the OpenTelemetry agent as it would require customizing the agent.JAR in order to get the propagator loaded.
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 1e668577c93..641b49f6c85 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -54,6 +54,9 @@ jobs:
           - sample: "sentry-samples-console"
             agent: "false"
             agent-auto-init: "true"
+          - sample: "sentry-samples-console-otlp"
+            agent: "false"
+            agent-auto-init: "true"
           - sample: "sentry-samples-logback"
             agent: "false"
             agent-auto-init: "true"
@@ -78,6 +81,9 @@ jobs:
           - sample: "sentry-samples-spring-boot-4-opentelemetry"
             agent: "true"
             agent-auto-init: "false"
+          - sample: "sentry-samples-spring-boot-4-otlp"
+            agent: "false"
+            agent-auto-init: "true"
           - sample: "sentry-samples-spring-7"
             agent: "false"
             agent-auto-init: "true"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b3de4ffc7e3..bf481f1cca3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@
 
 ### Features
 
+- Create `sentry-opentelemetry-otlp` and `sentry-opentelemetry-otlp-spring` modules for combining OpenTelemetry SDK OTLP export with Sentry SDK ([#5100](https://github.com/getsentry/sentry-java/pull/5100))
+  - OpenTelemetry is configured to send spans to Sentry directly using an OTLP endpoint.
+  - Sentry only uses trace and span ID from OpenTelemetry (via `OpenTelemetryOtlpEventProcessor`) but will not send spans through OpenTelemetry nor use OpenTelemetry `Context` for `Scopes` propagation.
+  - See the OTLP setup docs for [Java](https://docs.sentry.io/platforms/java/opentelemetry/setup/otlp/) and [Spring Boot](https://docs.sentry.io/platforms/java/guides/spring-boot/opentelemetry/setup/otlp/) for installation and configuration instructions.
 - Add screenshot masking support using view hierarchy ([#5077](https://github.com/getsentry/sentry-java/pull/5077))
   - Masks sensitive content (text, images) in error screenshots using the same view hierarchy approach as Session Replay
   - Requires the `sentry-android-replay` module to be present at runtime for masking to work
diff --git a/README.md b/README.md
index ee32d485f42..31285e2be29 100644
--- a/README.md
+++ b/README.md
@@ -65,6 +65,8 @@ Sentry SDK for Java and Android
 | sentry-opentelemetry-agent              | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-agent?style=for-the-badge&logo=sentry&color=green)              |
 | sentry-opentelemetry-agentcustomization | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-agentcustomization?style=for-the-badge&logo=sentry&color=green) |
 | sentry-opentelemetry-core               | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-core?style=for-the-badge&logo=sentry&color=green)               |
+| sentry-opentelemetry-otlp               | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-otlp?style=for-the-badge&logo=sentry&color=green)               |
+| sentry-opentelemetry-otlp-spring        | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-otlp-spring?style=for-the-badge&logo=sentry&color=green)        |
 | sentry-okhttp                           | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-okhttp?style=for-the-badge&logo=sentry&color=green)                           |
 | sentry-reactor                          | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-reactor?style=for-the-badge&logo=sentry&color=green)                          |
 | sentry-spotlight                        | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spotlight?style=for-the-badge&logo=sentry&color=green)                        |
diff --git a/build.gradle.kts b/build.gradle.kts
index b89b7deed10..376d0652832 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -77,6 +77,7 @@ apiValidation {
             "sentry-samples-spring-boot-4",
             "sentry-samples-spring-boot-4-opentelemetry",
             "sentry-samples-spring-boot-4-opentelemetry-noagent",
+            "sentry-samples-spring-boot-4-otlp",
             "sentry-samples-spring-boot-4-webflux",
             "sentry-samples-ktor-client",
             "sentry-uitest-android",
@@ -85,7 +86,8 @@ apiValidation {
             "test-app-plain",
             "test-app-sentry",
             "test-app-size",
-            "sentry-samples-netflix-dgs"
+            "sentry-samples-netflix-dgs",
+            "sentry-samples-console-otlp"
         )
     )
 }
diff --git a/buildSrc/src/main/java/Config.kt b/buildSrc/src/main/java/Config.kt
index 3b6a08ad26b..72892df5a9a 100644
--- a/buildSrc/src/main/java/Config.kt
+++ b/buildSrc/src/main/java/Config.kt
@@ -64,6 +64,8 @@ object Config {
         val SENTRY_SPRING_BOOT_4_STARTER_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.spring-boot-4-starter"
         val SENTRY_OPENTELEMETRY_BOOTSTRAP_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.opentelemetry.bootstrap"
         val SENTRY_OPENTELEMETRY_CORE_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.opentelemetry.core"
+        val SENTRY_OPENTELEMETRY_OTLP_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.opentelemetry.otlp"
+        val SENTRY_OPENTELEMETRY_OTLP_SPRING_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.opentelemetry.otlp-spring"
         val SENTRY_OPENTELEMETRY_AGENT_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.opentelemetry.agent"
         val SENTRY_OPENTELEMETRY_AGENTLESS_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.opentelemetry.agentless"
         val SENTRY_OPENTELEMETRY_AGENTLESS_SPRING_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.opentelemetry.agentless-spring"
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 7e9a7af4840..d283b549895 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -134,6 +134,8 @@ okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
 okhttp-bom = { module = "com.squareup.okhttp3:okhttp-bom", version.ref = "okhttp" }
 openfeature = { module = "dev.openfeature:sdk", version.ref = "openfeature" }
 otel = { module = "io.opentelemetry:opentelemetry-sdk", version.ref = "otel" }
+otel-exporter-otlp = { module = "io.opentelemetry:opentelemetry-exporter-otlp", version.ref = "otel" }
+otel-exporter-logging = { module = "io.opentelemetry:opentelemetry-exporter-logging", version.ref = "otel" }
 otel-extension-autoconfigure = { module = "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure", version.ref = "otel" }
 otel-extension-autoconfigure-spi = { module = "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure-spi", version.ref = "otel" }
 otel-instrumentation-bom = { module = "io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom", version.ref = "otelInstrumentation" }
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/README.md b/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/README.md
new file mode 100644
index 00000000000..1ce3ced134a
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/README.md
@@ -0,0 +1,7 @@
+# sentry-opentelemetry-otlp-spring
+
+This module combines `sentry-opentelemetry-otlp` with the OpenTelemetry Spring Boot Starter for a simpler setup in Spring Boot applications.
+
+It is intended for setups where OpenTelemetry handles tracing (with spans exported via OTLP to Sentry) while Sentry handles errors, logs, metrics, and other products.
+
+Please consult the documentation on how to install and use this integration in the [Sentry Docs for Java](https://docs.sentry.io/platforms/java/opentelemetry/setup/otlp/).
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/build.gradle.kts
new file mode 100644
index 00000000000..1ff16cd0a31
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/build.gradle.kts
@@ -0,0 +1,22 @@
+plugins {
+  `java-library`
+  id("io.sentry.javadoc")
+}
+
+dependencies {
+  api(projects.sentryOpentelemetry.sentryOpentelemetryOtlp)
+  implementation(libs.springboot3.otel)
+}
+
+tasks.jar {
+  manifest {
+    attributes(
+      "Sentry-Version-Name" to project.version,
+      "Sentry-SDK-Name" to Config.Sentry.SENTRY_OPENTELEMETRY_OTLP_SPRING_SDK_NAME,
+      "Sentry-SDK-Package-Name" to "maven:io.sentry:sentry-opentelemetry-otlp-spring",
+      "Implementation-Vendor" to "Sentry",
+      "Implementation-Title" to project.name,
+      "Implementation-Version" to project.version,
+    )
+  }
+}
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/README.md b/sentry-opentelemetry/sentry-opentelemetry-otlp/README.md
new file mode 100644
index 00000000000..c729ce27629
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/README.md
@@ -0,0 +1,7 @@
+# sentry-opentelemetry-otlp
+
+This module provides a lightweight integration for using OpenTelemetry alongside the Sentry SDK. It reads trace and span IDs from the OpenTelemetry `Context` so that Sentry events (errors, logs, metrics) are correlated with OpenTelemetry traces.
+
+Unlike the other `sentry-opentelemetry-*` modules, this module does not rely on OpenTelemetry for scope storage or span creation. It is intended for setups where OpenTelemetry handles performance/tracing and Sentry handles errors, logs, metrics, and other products.
+
+Please consult the documentation on how to install and use this integration in the [Sentry Docs for Java](https://docs.sentry.io/platforms/java/).
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/api/sentry-opentelemetry-otlp.api b/sentry-opentelemetry/sentry-opentelemetry-otlp/api/sentry-opentelemetry-otlp.api
new file mode 100644
index 00000000000..56e80e60ae6
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/api/sentry-opentelemetry-otlp.api
@@ -0,0 +1,22 @@
+public final class io/sentry/opentelemetry/otlp/OpenTelemetryOtlpEventProcessor : io/sentry/EventProcessor {
+	public fun <init> ()V
+	public fun getOrder ()Ljava/lang/Long;
+	public fun process (Lio/sentry/SentryEvent;Lio/sentry/Hint;)Lio/sentry/SentryEvent;
+	public fun process (Lio/sentry/SentryLogEvent;)Lio/sentry/SentryLogEvent;
+	public fun process (Lio/sentry/SentryMetricsEvent;Lio/sentry/Hint;)Lio/sentry/SentryMetricsEvent;
+}
+
+public final class io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator : io/opentelemetry/context/propagation/TextMapPropagator {
+	public static final field SENTRY_BAGGAGE_KEY Lio/opentelemetry/context/ContextKey;
+	public fun <init> ()V
+	public fun extract (Lio/opentelemetry/context/Context;Ljava/lang/Object;Lio/opentelemetry/context/propagation/TextMapGetter;)Lio/opentelemetry/context/Context;
+	public fun fields ()Ljava/util/Collection;
+	public fun inject (Lio/opentelemetry/context/Context;Ljava/lang/Object;Lio/opentelemetry/context/propagation/TextMapSetter;)V
+}
+
+public final class io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagatorProvider : io/opentelemetry/sdk/autoconfigure/spi/ConfigurablePropagatorProvider {
+	public fun <init> ()V
+	public fun getName ()Ljava/lang/String;
+	public fun getPropagator (Lio/opentelemetry/sdk/autoconfigure/spi/ConfigProperties;)Lio/opentelemetry/context/propagation/TextMapPropagator;
+}
+
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
new file mode 100644
index 00000000000..f039b3c95ef
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
@@ -0,0 +1,84 @@
+import net.ltgt.gradle.errorprone.errorprone
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  `java-library`
+  id("io.sentry.javadoc")
+  alias(libs.plugins.kotlin.jvm)
+  jacoco
+  alias(libs.plugins.errorprone)
+  alias(libs.plugins.gradle.versions)
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
+}
+
+dependencies {
+  api(projects.sentry)
+
+  api(libs.otel)
+  api(libs.otel.extension.autoconfigure)
+  api(libs.otel.exporter.otlp)
+  compileOnly(libs.otel.extension.autoconfigure.spi)
+  //  compileOnly(libs.otel.semconv)
+  //  compileOnly(libs.otel.semconv.incubating)
+
+  compileOnly(libs.jetbrains.annotations)
+  compileOnly(libs.nopen.annotations)
+  errorprone(libs.errorprone.core)
+  errorprone(libs.nopen.checker)
+  errorprone(libs.nullaway)
+
+  // tests
+  testImplementation(projects.sentryTestSupport)
+  testImplementation(kotlin(Config.kotlinStdLib))
+  testImplementation(libs.awaitility.kotlin)
+  testImplementation(libs.kotlin.test.junit)
+  testImplementation(libs.mockito.kotlin)
+
+  testImplementation(libs.otel)
+  //  testImplementation(libs.otel.semconv)
+  //  testImplementation(libs.otel.semconv.incubating)
+}
+
+configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
+
+jacoco { toolVersion = libs.versions.jacoco.get() }
+
+tasks.jacocoTestReport {
+  reports {
+    xml.required.set(true)
+    html.required.set(false)
+  }
+}
+
+tasks {
+  jacocoTestCoverageVerification {
+    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
+  }
+  check {
+    dependsOn(jacocoTestCoverageVerification)
+    dependsOn(jacocoTestReport)
+  }
+}
+
+tasks.withType<JavaCompile>().configureEach {
+  options.errorprone {
+    check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
+    option("NullAway:AnnotatedPackages", "io.sentry")
+  }
+}
+
+tasks.jar {
+  manifest {
+    attributes(
+      "Sentry-Version-Name" to project.version,
+      "Sentry-SDK-Name" to Config.Sentry.SENTRY_OPENTELEMETRY_OTLP_SDK_NAME,
+      "Sentry-SDK-Package-Name" to "maven:io.sentry:sentry-opentelemetry-otlp",
+      "Implementation-Vendor" to "Sentry",
+      "Implementation-Title" to project.name,
+      "Implementation-Version" to project.version,
+    )
+  }
+}
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpEventProcessor.java b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpEventProcessor.java
new file mode 100644
index 00000000000..ad8b672c7de
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpEventProcessor.java
@@ -0,0 +1,120 @@
+package io.sentry.opentelemetry.otlp;
+
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanId;
+import io.opentelemetry.api.trace.TraceId;
+import io.sentry.EventProcessor;
+import io.sentry.Hint;
+import io.sentry.IScopes;
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryEvent;
+import io.sentry.SentryLevel;
+import io.sentry.SentryLogEvent;
+import io.sentry.SentryMetricsEvent;
+import io.sentry.SpanContext;
+import io.sentry.protocol.SentryId;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
+
+public final class OpenTelemetryOtlpEventProcessor implements EventProcessor {
+
+  private final @NotNull IScopes scopes;
+
+  public OpenTelemetryOtlpEventProcessor() {
+    this(ScopesAdapter.getInstance());
+  }
+
+  @TestOnly
+  OpenTelemetryOtlpEventProcessor(final @NotNull IScopes scopes) {
+    this.scopes = scopes;
+  }
+
+  @Override
+  public @Nullable SentryEvent process(final @NotNull SentryEvent event, final @NotNull Hint hint) {
+    @NotNull final Span otelSpan = Span.current();
+    @NotNull final String traceId = otelSpan.getSpanContext().getTraceId();
+    @NotNull final String spanId = otelSpan.getSpanContext().getSpanId();
+
+    if (TraceId.isValid(traceId) && SpanId.isValid(spanId)) {
+      final @NotNull SpanContext spanContext =
+          new SpanContext(
+              new SentryId(traceId), new io.sentry.SpanId(spanId), "opentelemetry", null, null);
+
+      event.getContexts().setTrace(spanContext);
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.DEBUG,
+              "Linking Sentry event %s to span %s created via OpenTelemetry (trace %s).",
+              event.getEventId(),
+              spanId,
+              traceId);
+    } else {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.DEBUG,
+              "Not linking Sentry event %s to any transaction created via OpenTelemetry as traceId %s or spanId %s are invalid.",
+              event.getEventId(),
+              traceId,
+              spanId);
+    }
+
+    return event;
+  }
+
+  @Override
+  public @Nullable SentryLogEvent process(@NotNull SentryLogEvent event) {
+    @NotNull final Span otelSpan = Span.current();
+    @NotNull final String traceId = otelSpan.getSpanContext().getTraceId();
+    @NotNull final String spanId = otelSpan.getSpanContext().getSpanId();
+
+    if (TraceId.isValid(traceId) && SpanId.isValid(spanId)) {
+      event.setTraceId(new SentryId(traceId));
+      event.setSpanId(new io.sentry.SpanId(spanId));
+    } else {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.DEBUG,
+              "Not linking Sentry event to any transaction created via OpenTelemetry as traceId %s or spanId %s are invalid.",
+              traceId,
+              spanId);
+    }
+
+    return event;
+  }
+
+  @Override
+  public @Nullable SentryMetricsEvent process(
+      @NotNull SentryMetricsEvent event, @NotNull Hint hint) {
+    @NotNull final Span otelSpan = Span.current();
+    @NotNull final String traceId = otelSpan.getSpanContext().getTraceId();
+    @NotNull final String spanId = otelSpan.getSpanContext().getSpanId();
+
+    if (TraceId.isValid(traceId) && SpanId.isValid(spanId)) {
+      event.setTraceId(new SentryId(traceId));
+      event.setSpanId(new io.sentry.SpanId(spanId));
+    } else {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.DEBUG,
+              "Not linking Sentry event to any transaction created via OpenTelemetry as traceId %s or spanId %s are invalid.",
+              traceId,
+              spanId);
+    }
+
+    return event;
+  }
+
+  @Override
+  public @Nullable Long getOrder() {
+    return 6000L;
+  }
+}
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java
new file mode 100644
index 00000000000..e6bc31ca827
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java
@@ -0,0 +1,129 @@
+package io.sentry.opentelemetry.otlp;
+
+import static io.sentry.SentryTraceHeader.SENTRY_TRACE_HEADER;
+
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.SpanContext;
+import io.opentelemetry.api.trace.TraceFlags;
+import io.opentelemetry.api.trace.TraceState;
+import io.opentelemetry.context.Context;
+import io.opentelemetry.context.ContextKey;
+import io.opentelemetry.context.propagation.TextMapGetter;
+import io.opentelemetry.context.propagation.TextMapPropagator;
+import io.opentelemetry.context.propagation.TextMapSetter;
+import io.sentry.Baggage;
+import io.sentry.BaggageHeader;
+import io.sentry.IScopes;
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryLevel;
+import io.sentry.SentryTraceHeader;
+import io.sentry.exception.InvalidSentryTraceHeaderException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class OpenTelemetryOtlpPropagator implements TextMapPropagator {
+
+  private static final @NotNull List<String> FIELDS =
+      Arrays.asList(SENTRY_TRACE_HEADER, BaggageHeader.BAGGAGE_HEADER);
+
+  public static final @NotNull ContextKey<Baggage> SENTRY_BAGGAGE_KEY =
+      ContextKey.named("sentry.baggage");
+  private final @NotNull IScopes scopes;
+
+  public OpenTelemetryOtlpPropagator() {
+    this(ScopesAdapter.getInstance());
+  }
+
+  OpenTelemetryOtlpPropagator(final @NotNull IScopes scopes) {
+    this.scopes = scopes;
+  }
+
+  @Override
+  public Collection<String> fields() {
+    return FIELDS;
+  }
+
+  @Override
+  public <C> void inject(final Context context, final C carrier, final TextMapSetter<C> setter) {
+    final @NotNull Span otelSpan = Span.fromContext(context);
+    final @NotNull SpanContext otelSpanContext = otelSpan.getSpanContext();
+    if (!otelSpanContext.isValid()) {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.DEBUG,
+              "Not injecting Sentry tracing information for invalid OpenTelemetry span.");
+      return;
+    }
+
+    setter.set(
+        carrier,
+        SENTRY_TRACE_HEADER,
+        otelSpanContext.getTraceId()
+            + "-"
+            + otelSpanContext.getSpanId()
+            + "-"
+            + (otelSpanContext.isSampled() ? "1" : "0"));
+
+    final @Nullable Baggage baggage = context.get(SENTRY_BAGGAGE_KEY);
+    if (baggage != null) {
+      setter.set(carrier, BaggageHeader.BAGGAGE_HEADER, baggage.toHeaderString(null));
+    }
+  }
+
+  @Override
+  public <C> Context extract(
+      final Context context, final C carrier, final TextMapGetter<C> getter) {
+    final @Nullable String sentryTraceString = getter.get(carrier, SENTRY_TRACE_HEADER);
+    if (sentryTraceString == null) {
+      return context;
+    }
+
+    try {
+      SentryTraceHeader sentryTraceHeader = new SentryTraceHeader(sentryTraceString);
+
+      final @Nullable String baggageString = getter.get(carrier, BaggageHeader.BAGGAGE_HEADER);
+      final @NotNull TraceState traceState = TraceState.getDefault();
+
+      final @NotNull TraceFlags traceFlags =
+          Boolean.FALSE.equals(sentryTraceHeader.isSampled())
+              ? TraceFlags.getDefault()
+              : TraceFlags.getSampled();
+
+      SpanContext otelSpanContext =
+          SpanContext.createFromRemoteParent(
+              sentryTraceHeader.getTraceId().toString(),
+              sentryTraceHeader.getSpanId().toString(),
+              traceFlags,
+              traceState);
+
+      Span wrappedSpan = Span.wrap(otelSpanContext);
+
+      @NotNull Context modifiedContext = context.with(wrappedSpan);
+      if (baggageString != null) {
+        modifiedContext =
+            modifiedContext.with(SENTRY_BAGGAGE_KEY, Baggage.fromHeader(baggageString));
+      }
+
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(SentryLevel.DEBUG, "Continuing Sentry trace %s", sentryTraceHeader.getTraceId());
+
+      return modifiedContext;
+    } catch (InvalidSentryTraceHeaderException e) {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.ERROR,
+              "Unable to extract Sentry tracing information from invalid header.",
+              e);
+      return context;
+    }
+  }
+}
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagatorProvider.java b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagatorProvider.java
new file mode 100644
index 00000000000..503729a750d
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagatorProvider.java
@@ -0,0 +1,17 @@
+package io.sentry.opentelemetry.otlp;
+
+import io.opentelemetry.context.propagation.TextMapPropagator;
+import io.opentelemetry.sdk.autoconfigure.spi.ConfigProperties;
+import io.opentelemetry.sdk.autoconfigure.spi.ConfigurablePropagatorProvider;
+
+public final class OpenTelemetryOtlpPropagatorProvider implements ConfigurablePropagatorProvider {
+  @Override
+  public TextMapPropagator getPropagator(ConfigProperties config) {
+    return new OpenTelemetryOtlpPropagator();
+  }
+
+  @Override
+  public String getName() {
+    return "sentry";
+  }
+}
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ConfigurablePropagatorProvider b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ConfigurablePropagatorProvider
new file mode 100644
index 00000000000..0bd359e1395
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/resources/META-INF/services/io.opentelemetry.sdk.autoconfigure.spi.ConfigurablePropagatorProvider
@@ -0,0 +1 @@
+io.sentry.opentelemetry.otlp.OpenTelemetryOtlpPropagatorProvider
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt
new file mode 100644
index 00000000000..e9bfe26c11d
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt
@@ -0,0 +1,184 @@
+package io.sentry.opentelemetry.otlp
+
+import io.opentelemetry.api.trace.Span
+import io.opentelemetry.api.trace.SpanContext
+import io.opentelemetry.api.trace.TraceFlags
+import io.opentelemetry.api.trace.TraceState
+import io.opentelemetry.context.Context
+import io.opentelemetry.context.propagation.TextMapGetter
+import io.opentelemetry.context.propagation.TextMapSetter
+import io.sentry.Baggage
+import io.sentry.Sentry
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class OpenTelemetryOtlpPropagatorTest {
+
+  @BeforeTest
+  fun setup() {
+    Sentry.init("https://key@sentry.io/proj")
+  }
+
+  @Test
+  fun `propagator registers for sentry-trace and baggage`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    assertEquals(listOf("sentry-trace", "baggage"), propagator.fields())
+  }
+
+  @Test
+  fun `invalid sentry trace header returns context without modification`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier: Map<String, String> =
+      mapOf(
+        "sentry-trace" to "wrong",
+        "baggage" to
+          "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d",
+      )
+    val scopeInContext = Sentry.forkedRootScopes("test")
+
+    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
+
+    val baggage = newContext.get(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY)
+    assertNull(baggage)
+  }
+
+  @Test
+  fun `uses incoming headers`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier: Map<String, String> =
+      mapOf(
+        "sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1",
+        "baggage" to
+          "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d",
+      )
+    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
+
+    val span = Span.fromContext(newContext)
+    assertEquals("f9118105af4a2d42b4124532cd1065ff", span.spanContext.traceId)
+    assertEquals("424cffc8f94feeee", span.spanContext.spanId)
+    assertTrue(span.spanContext.isSampled)
+
+    assertEquals(
+      "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d",
+      newContext.get(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY)?.toHeaderString(null),
+    )
+  }
+
+  @Test
+  fun `extract does not store baggage in context when baggage header is missing`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier: Map<String, String> =
+      mapOf("sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1")
+    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
+
+    assertNull(newContext.get(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY))
+  }
+
+  @Test
+  fun `does not inject baggage header when baggage is missing from context`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier = mutableMapOf<String, String>()
+
+    val otelSpanContext =
+      SpanContext.create(
+        "f9118105af4a2d42b4124532cd1065ff",
+        "424cffc8f94feeee",
+        TraceFlags.getSampled(),
+        TraceState.getDefault(),
+      )
+    val otelSpan = Span.wrap(otelSpanContext)
+    val context = Context.root().with(otelSpan)
+
+    propagator.inject(context, carrier, MapSetter())
+
+    assertEquals("f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1", carrier["sentry-trace"])
+    assertNull(carrier["baggage"])
+  }
+
+  @Test
+  fun `extract sets sampled trace flag when sentry-trace has sampled=0`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier: Map<String, String> =
+      mapOf("sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-0")
+    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
+
+    val span = Span.fromContext(newContext)
+    assertEquals("f9118105af4a2d42b4124532cd1065ff", span.spanContext.traceId)
+    assertEquals("424cffc8f94feeee", span.spanContext.spanId)
+    assertFalse(span.spanContext.isSampled)
+  }
+
+  @Test
+  fun `extract sets sampled trace flag when sentry-trace has no sampling decision`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier: Map<String, String> =
+      mapOf("sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee")
+    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
+
+    val span = Span.fromContext(newContext)
+    assertEquals("f9118105af4a2d42b4124532cd1065ff", span.spanContext.traceId)
+    assertEquals("424cffc8f94feeee", span.spanContext.spanId)
+    assertTrue(span.spanContext.isSampled)
+  }
+
+  @Test
+  fun `injects headers`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier = mutableMapOf<String, String>()
+
+    val otelSpanContext =
+      SpanContext.create(
+        "f9118105af4a2d42b4124532cd1065ff",
+        "424cffc8f94feeee",
+        TraceFlags.getSampled(),
+        TraceState.getDefault(),
+      )
+    val otelSpan = Span.wrap(otelSpanContext)
+
+    val context =
+      Context.root()
+        .with(otelSpan)
+        .with(
+          OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY,
+          Baggage.fromHeader(
+            "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d"
+          ),
+        )
+
+    propagator.inject(context, carrier, MapSetter())
+
+    assertEquals("f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1", carrier["sentry-trace"])
+    assertEquals(
+      "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d",
+      carrier["baggage"],
+    )
+  }
+
+  @Test
+  fun `does not inject headers if span is invalid`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier = mutableMapOf<String, String>()
+
+    propagator.inject(Context.root().with(Span.getInvalid()), carrier, MapSetter())
+
+    assertNull(carrier["sentry-trace"])
+    assertNull(carrier["baggage"])
+  }
+}
+
+class MapGetter : TextMapGetter<Map<String, String>> {
+  override fun keys(carrier: Map<String, String>): MutableIterable<String> =
+    carrier.keys.toMutableList()
+
+  override fun get(carrier: Map<String, String>?, key: String): String? = carrier?.get(key)
+}
+
+class MapSetter : TextMapSetter<MutableMap<String, String>> {
+  override fun set(carrier: MutableMap<String, String>?, key: String, value: String) {
+    carrier?.set(key, value)
+  }
+}
diff --git a/sentry-samples/sentry-samples-console-otlp/README.md b/sentry-samples/sentry-samples-console-otlp/README.md
new file mode 100644
index 00000000000..a1e7314fdac
--- /dev/null
+++ b/sentry-samples/sentry-samples-console-otlp/README.md
@@ -0,0 +1,13 @@
+# Sentry Sample Console OTLP
+
+Sample application showing how to use Sentry with OTLP without any framework integration.
+
+## How to run?
+
+To see events triggered in this sample application in your Sentry dashboard, go to `src/main/java/io/sentry/samples/console/Main.java` and replace the test DSN with your own DSN.
+
+Then, execute a command from the module directory:
+
+```
+../../gradlew run
+```
diff --git a/sentry-samples/sentry-samples-console-otlp/api/sentry-samples-console-otlp.api b/sentry-samples/sentry-samples-console-otlp/api/sentry-samples-console-otlp.api
new file mode 100644
index 00000000000..867869223ea
--- /dev/null
+++ b/sentry-samples/sentry-samples-console-otlp/api/sentry-samples-console-otlp.api
@@ -0,0 +1,5 @@
+public class io/sentry/samples/console/Main {
+	public fun <init> ()V
+	public static fun main ([Ljava/lang/String;)V
+}
+
diff --git a/sentry-samples/sentry-samples-console-otlp/build.gradle.kts b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
new file mode 100644
index 00000000000..18836c89555
--- /dev/null
+++ b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
@@ -0,0 +1,87 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  java
+  application
+  alias(libs.plugins.kotlin.jvm)
+  alias(libs.plugins.gradle.versions)
+  id("com.github.johnrengelman.shadow") version "8.1.1"
+}
+
+application { mainClass.set("io.sentry.samples.console.Main") }
+
+java.sourceCompatibility = JavaVersion.VERSION_17
+
+java.targetCompatibility = JavaVersion.VERSION_17
+
+repositories { mavenCentral() }
+
+configure<JavaPluginExtension> {
+  sourceCompatibility = JavaVersion.VERSION_17
+  targetCompatibility = JavaVersion.VERSION_17
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+  kotlin {
+    compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
+    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+  }
+}
+
+dependencies {
+  implementation(projects.sentryOpentelemetry.sentryOpentelemetryOtlp)
+  implementation(projects.sentryAsyncProfiler)
+  implementation(libs.otel.semconv)
+  implementation(libs.otel.semconv.incubating)
+  implementation(libs.otel.exporter.logging)
+
+  testImplementation(kotlin(Config.kotlinStdLib))
+  testImplementation(projects.sentry)
+  testImplementation(projects.sentrySystemTestSupport)
+  testImplementation(libs.kotlin.test.junit)
+  testImplementation(libs.slf4j.api)
+  testImplementation(libs.slf4j.jdk14)
+}
+
+// Configure the Shadow JAR (executable JAR with all dependencies)
+tasks.shadowJar {
+  manifest { attributes["Main-Class"] = "io.sentry.samples.console.Main" }
+  archiveClassifier.set("") // Remove the classifier so it replaces the regular JAR
+  mergeServiceFiles()
+}
+
+// Make the regular jar task depend on shadowJar
+tasks.jar {
+  enabled = false
+  dependsOn(tasks.shadowJar)
+}
+
+// Fix the startScripts task dependency
+tasks.startScripts { dependsOn(tasks.shadowJar) }
+
+configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
+
+tasks.register<Test>("systemTest").configure {
+  group = "verification"
+  description = "Runs the System tests"
+
+  outputs.upToDateWhen { false }
+
+  maxParallelForks = 1
+
+  // Cap JVM args per test
+  minHeapSize = "128m"
+  maxHeapSize = "1g"
+
+  filter { includeTestsMatching("io.sentry.systemtest*") }
+}
+
+tasks.named("test").configure {
+  require(this is Test)
+
+  filter { excludeTestsMatching("io.sentry.systemtest.*") }
+}
diff --git a/sentry-samples/sentry-samples-console-otlp/src/main/java/io/sentry/samples/console/Main.java b/sentry-samples/sentry-samples-console-otlp/src/main/java/io/sentry/samples/console/Main.java
new file mode 100644
index 00000000000..d973a68a907
--- /dev/null
+++ b/sentry-samples/sentry-samples-console-otlp/src/main/java/io/sentry/samples/console/Main.java
@@ -0,0 +1,244 @@
+package io.sentry.samples.console;
+
+import io.opentelemetry.api.GlobalOpenTelemetry;
+import io.opentelemetry.api.trace.Span;
+import io.opentelemetry.api.trace.StatusCode;
+import io.opentelemetry.context.Scope;
+import io.opentelemetry.sdk.autoconfigure.AutoConfiguredOpenTelemetrySdk;
+import io.sentry.*;
+import io.sentry.clientreport.DiscardReason;
+import io.sentry.opentelemetry.otlp.OpenTelemetryOtlpEventProcessor;
+import io.sentry.protocol.Message;
+import io.sentry.protocol.User;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Main {
+
+  private static long numberOfDiscardedSpansDueToOverflow = 0;
+
+  public static void main(String[] args) throws InterruptedException {
+    // Configure OpenTelemetry SDK with Sentry OTLP propagator
+    AutoConfiguredOpenTelemetrySdk.builder()
+        .setResultAsGlobal()
+        .addPropertiesSupplier(
+            () -> {
+              final Map<String, String> properties = new HashMap<>();
+              properties.put("otel.logs.exporter", "none");
+              properties.put("otel.metrics.exporter", "none");
+              // OTLP traces exporter configuration
+              properties.put("otel.traces.exporter", "otlp,logging");
+              properties.put(
+                  "otel.exporter.otlp.traces.endpoint",
+                  "https://o447951.ingest.us.sentry.io/api/5428563/integration/otlp/v1/traces");
+              properties.put("otel.exporter.otlp.traces.protocol", "http/protobuf");
+              properties.put(
+                  "otel.exporter.otlp.traces.headers",
+                  "x-sentry-auth=sentry sentry_key=502f25099c204a2fbf4cb16edc5975d1");
+              properties.put("otel.propagators", "tracecontext,baggage,sentry");
+              return properties;
+            })
+        .build();
+
+    Sentry.init(
+        options -> {
+          // NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in
+          // your Sentry project/dashboard
+          options.setEnableExternalConfiguration(true);
+          options.setDsn(
+              "https://502f25099c204a2fbf4cb16edc5975d1@o447951.ingest.sentry.io/5428563");
+
+          // All events get assigned to the release. See more at
+          // https://docs.sentry.io/workflow/releases/
+          options.setRelease("io.sentry.samples.console@3.0.0+1");
+
+          // Link Sentry events to OpenTelemetry spans
+          options.addEventProcessor(new OpenTelemetryOtlpEventProcessor());
+
+          // Modifications to event before it goes out. Could replace the event altogether
+          options.setBeforeSend(
+              (event, hint) -> {
+                // Drop an event altogether:
+                if (event.getTag("SomeTag") != null) {
+                  return null;
+                }
+                return event;
+              });
+
+          options.setBeforeSendTransaction(
+              (transaction, hint) -> {
+                // Drop a transaction:
+                if (transaction.getTag("SomeTransactionTag") != null) {
+                  return null;
+                }
+
+                return transaction;
+              });
+
+          // Allows inspecting and modifying, returning a new or simply rejecting (returning null)
+          options.setBeforeBreadcrumb(
+              (breadcrumb, hint) -> {
+                // Don't add breadcrumbs with message containing:
+                if (breadcrumb.getMessage() != null
+                    && breadcrumb.getMessage().contains("bad breadcrumb")) {
+                  return null;
+                }
+                return breadcrumb;
+              });
+
+          // Record data being discarded, including the reason, type of data, and the number of
+          // items dropped
+          options.setOnDiscard(
+              (reason, category, number) -> {
+                // Only record the number of lost spans due to overflow conditions
+                if ((reason.equals(DiscardReason.CACHE_OVERFLOW)
+                        || reason.equals(DiscardReason.QUEUE_OVERFLOW))
+                    && category.equals(DataCategory.Span)) {
+                  numberOfDiscardedSpansDueToOverflow += number;
+                }
+              });
+
+          // Configure the background worker which sends events to sentry:
+          // Wait up to 5 seconds before shutdown while there are events to send.
+          options.setShutdownTimeoutMillis(5000);
+
+          // Enable SDK logging with Debug level
+          options.setDebug(true);
+          // To change the verbosity, use:
+          // By default it's DEBUG.
+          // options.setDiagnosticLevel(SentryLevel.ERROR);
+          // A good option to have SDK debug log in prod is to use only level ERROR here.
+
+          // Exclude frames from some packages from being "inApp" so are hidden by default in Sentry
+          // UI:
+          options.addInAppExclude("org.jboss");
+
+          // Include frames from our package
+          options.addInAppInclude("io.sentry.samples");
+
+          // Performance configuration options
+          // Set what percentage of traces should be collected
+          //          options.setTracesSampleRate(1.0); // set 0.5 to send 50% of traces
+
+          // Determine traces sample rate based on the sampling context
+          //          options.setTracesSampler(
+          //              context -> {
+          //                // only 10% of transactions with "/product" prefix will be collected
+          //                if (!context.getTransactionContext().getName().startsWith("/products"))
+          // {
+          //                  return 0.1;
+          //                } else {
+          //                  return 0.5;
+          //                }
+          //              });
+
+          options.getLogs().setEnabled(true);
+        });
+
+    Sentry.addBreadcrumb(
+        "A 'bad breadcrumb' that will be rejected because of 'BeforeBreadcrumb callback above.'");
+
+    // Data added to the root scope (no PushScope called up to this point)
+    // The modifications done here will affect all events sent and will propagate to child scopes.
+    Sentry.configureScope(
+        scope -> {
+          scope.addEventProcessor(new SomeEventProcessor());
+
+          scope.setExtra("SomeExtraInfo", "Some value for extra info");
+        });
+
+    // Configures a scope which is only valid within the callback
+    Sentry.withScope(
+        scope -> {
+          scope.setLevel(SentryLevel.FATAL);
+          scope.setTransaction("main");
+
+          // This message includes the data set to the scope in this block:
+          Sentry.captureMessage("Fatal message!");
+        });
+
+    // Only data added to the scope on `configureScope` above is included.
+    Sentry.captureMessage("Some warning!", SentryLevel.WARNING);
+
+    Sentry.addFeatureFlag("my-feature-flag", true);
+
+    captureMetrics();
+
+    // Sending exception:
+    Exception exception = new RuntimeException("Some error!");
+    Sentry.captureException(exception);
+
+    // An event with breadcrumb and user data
+    SentryEvent evt = new SentryEvent();
+    Message msg = new Message();
+    msg.setMessage("Detailed event");
+    evt.setMessage(msg);
+    evt.addBreadcrumb("Breadcrumb directly to the event");
+    User user = new User();
+    user.setUsername("some@user");
+    evt.setUser(user);
+    // Group all events with the following fingerprint:
+    evt.setFingerprints(Collections.singletonList("NewClientDebug"));
+    evt.setLevel(SentryLevel.DEBUG);
+    Sentry.captureEvent(evt);
+
+    int count = 10;
+    for (int i = 0; i < count; i++) {
+      String messageContent = "%d of %d items we'll wait to flush to Sentry!";
+      Message message = new Message();
+      message.setMessage(messageContent);
+      message.setFormatted(String.format(messageContent, i, count));
+      SentryEvent event = new SentryEvent();
+      event.setMessage(message);
+
+      final Hint hint = new Hint();
+      hint.set("level", SentryLevel.DEBUG);
+      Sentry.captureEvent(event, hint);
+    }
+
+    // Create an OpenTelemetry span that will be linked to the Sentry trace
+    Span otelSpan =
+        GlobalOpenTelemetry.get()
+            .getTracer("demoTracer", "1.0.0")
+            .spanBuilder("otelSpan")
+            .startSpan();
+    try (Scope innerScope = otelSpan.makeCurrent()) {
+      otelSpan.setAttribute("otel-attribute", "attribute-value");
+
+      // Every SentryEvent reported during the execution of the transaction or a span, will have
+      // trace
+      // context attached
+      Sentry.captureMessage("this message is connected to the outerSpan");
+
+      Sentry.logger().error("Some error log message");
+      Sentry.metrics().count("invocations");
+
+      otelSpan.setStatus(StatusCode.OK);
+    } finally {
+      otelSpan.end();
+    }
+
+    // All events that have not been sent yet are being flushed on JVM exit. Events can be also
+    // flushed manually:
+    // Sentry.close();
+  }
+
+  private static void captureMetrics() {
+    Sentry.metrics().count("countMetric");
+    Sentry.metrics().gauge("gaugeMetric", 5.0);
+    Sentry.metrics().distribution("distributionMetric", 7.0);
+  }
+
+  private static class SomeEventProcessor implements EventProcessor {
+    @Override
+    public SentryEvent process(SentryEvent event, Hint hint) {
+      // Here you can modify the event as you need
+      if (event.getLevel() != null && event.getLevel().ordinal() > SentryLevel.INFO.ordinal()) {
+        event.addBreadcrumb(new Breadcrumb("Processed by " + SomeEventProcessor.class));
+      }
+
+      return event;
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-console-otlp/src/test/kotlin/io/sentry/DummyTest.kt b/sentry-samples/sentry-samples-console-otlp/src/test/kotlin/io/sentry/DummyTest.kt
new file mode 100644
index 00000000000..6f762b7e453
--- /dev/null
+++ b/sentry-samples/sentry-samples-console-otlp/src/test/kotlin/io/sentry/DummyTest.kt
@@ -0,0 +1,12 @@
+package io.sentry
+
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class DummyTest {
+  @Test
+  fun `the only test`() {
+    // only needed to have more than 0 tests and not fail the build
+    assertTrue(true)
+  }
+}
diff --git a/sentry-samples/sentry-samples-console-otlp/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt b/sentry-samples/sentry-samples-console-otlp/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
new file mode 100644
index 00000000000..1333fa50387
--- /dev/null
+++ b/sentry-samples/sentry-samples-console-otlp/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
@@ -0,0 +1,107 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import java.util.concurrent.TimeUnit
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+class ConsoleApplicationSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8000")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `console application sends expected events when run as JAR`() {
+    val jarFile = testHelper.findJar("sentry-samples-console-otlp")
+    val process =
+      testHelper.launch(
+        jarFile,
+        mapOf(
+          "SENTRY_DSN" to testHelper.dsn,
+          "SENTRY_ENABLE_PRETTY_SERIALIZATION_OUTPUT" to "false",
+          "SENTRY_DEBUG" to "true",
+        ),
+      )
+
+    process.waitFor(30, TimeUnit.SECONDS)
+    assertEquals(0, process.exitValue())
+
+    // Verify that we received the expected events
+    verifyExpectedEvents()
+  }
+
+  private fun verifyExpectedEvents() {
+    // Verify we received a "Fatal message!" event
+    testHelper.ensureErrorReceived { event ->
+      event.message?.formatted == "Fatal message!" && event.level?.name == "FATAL"
+    }
+
+    // Verify we received a "Some warning!" event
+    testHelper.ensureErrorReceived { event ->
+      event.message?.formatted == "Some warning!" && event.level?.name == "WARNING"
+    }
+
+    // Verify we received the RuntimeException
+    testHelper.ensureErrorReceived { event ->
+      event.exceptions?.any { ex -> ex.type == "RuntimeException" && ex.value == "Some error!" } ==
+        true && testHelper.doesEventHaveFlag(event, "my-feature-flag", true)
+    }
+
+    // Verify we received the detailed event with fingerprint
+    testHelper.ensureErrorReceived { event ->
+      event.message?.message == "Detailed event" &&
+        event.fingerprints?.contains("NewClientDebug") == true &&
+        event.level?.name == "DEBUG"
+    }
+
+    // Verify we received the loop messages (should be 10 of them)
+    var loopMessageCount = 0
+    try {
+      for (i in 0..9) {
+        testHelper.ensureErrorReceived { event ->
+          val matches =
+            event.message?.message?.contains("items we'll wait to flush to Sentry!") == true
+          if (matches) loopMessageCount++
+          matches
+        }
+      }
+    } catch (e: Exception) {
+      // Some loop messages might be missing, but we should have at least some
+    }
+
+    assertTrue(
+      "Should receive at least 5 loop messages, got $loopMessageCount",
+      loopMessageCount >= 5,
+    )
+
+    // Verify we received the message captured within the OTel span
+    testHelper.ensureErrorReceived { event ->
+      event.message?.formatted == "this message is connected to the outerSpan"
+    }
+
+    // Verify we have breadcrumbs
+    testHelper.ensureErrorReceived { event ->
+      event.breadcrumbs?.any { breadcrumb ->
+        breadcrumb.message?.contains("Processed by") == true
+      } == true
+    }
+
+    testHelper.ensureMetricsReceived { metricsEvents, sentryEnvelopeHeader ->
+      testHelper.doesContainMetric(metricsEvents, "countMetric", "counter", 1.0) &&
+        testHelper.doesContainMetric(metricsEvents, "gaugeMetric", "gauge", 5.0) &&
+        testHelper.doesContainMetric(metricsEvents, "distributionMetric", "distribution", 7.0) &&
+        testHelper.doesContainMetric(metricsEvents, "invocations", "counter", 1.0)
+    }
+
+    // Verify we received the log message captured within the OTel span
+    testHelper.ensureLogsReceived { logs, _ ->
+      testHelper.doesContainLogWithBody(logs, "Some error log message")
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/README.md b/sentry-samples/sentry-samples-spring-boot-4-otlp/README.md
new file mode 100644
index 00000000000..58b94ba8997
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/README.md
@@ -0,0 +1,122 @@
+# Sentry Sample Spring Boot 3.0+
+
+Sample application showing how to use Sentry with [Spring boot](http://spring.io/projects/spring-boot) from version `3.0` onwards.
+
+## How to run? 
+
+To see events triggered in this sample application in your Sentry dashboard, go to `src/main/resources/application.properties` and replace the test DSN with your own DSN.
+
+Then, execute a command from the module directory:
+
+```
+../../gradlew bootRun
+```
+
+Make an HTTP request that will trigger events:
+
+```
+curl -XPOST --user user:password http://localhost:8080/person/ -H "Content-Type:application/json" -d '{"firstName":"John","lastName":"Smith"}'
+```
+
+## GraphQL
+
+The following queries can be used to test the GraphQL integration.
+
+### Greeting
+```
+{
+    greeting(name: "crash")
+}
+```
+
+### Greeting with variables
+
+```
+query GreetingQuery($name: String) {
+    greeting(name: $name)
+}
+```
+variables:
+```
+{
+    "name": "crash"
+}
+```
+
+### Project
+
+```
+query ProjectQuery($slug: ID!) {
+    project(slug: $slug) {
+        slug
+        name
+        repositoryUrl
+        status
+    }
+}
+```
+variables:
+```
+{
+    "slug": "statuscrash"
+}
+```
+
+### Mutation
+
+```
+mutation AddProjectMutation($slug: ID!) {
+    addProject(slug: $slug)
+}
+```
+variables:
+```
+{
+    "slug": "nocrash",
+    "name": "nocrash"
+}
+```
+
+### Subscription
+
+```
+subscription SubscriptionNotifyNewTask($slug: ID!) {
+    notifyNewTask(projectSlug: $slug) {
+        id
+        name
+        assigneeId
+        assignee {
+            id
+            name
+        }
+    }
+}
+```
+variables:
+```
+{
+    "slug": "crash"
+}
+```
+
+### Data loader
+
+```
+query TasksAndAssigneesQuery($slug: ID!) {
+    tasks(projectSlug: $slug) {
+        id
+        name
+        assigneeId
+        assignee {
+            id
+            name
+        }
+    }
+}
+```
+variables:
+```
+{
+    "slug": "crash"
+}
+```
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
new file mode 100644
index 00000000000..4f3d64524fd
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
@@ -0,0 +1,101 @@
+import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  alias(libs.plugins.springboot4)
+  alias(libs.plugins.spring.dependency.management)
+  alias(libs.plugins.kotlin.jvm)
+  alias(libs.plugins.kotlin.spring)
+}
+
+group = "io.sentry.sample.spring-boot-4-otlp"
+
+version = "0.0.1-SNAPSHOT"
+
+java.sourceCompatibility = JavaVersion.VERSION_17
+
+java.targetCompatibility = JavaVersion.VERSION_17
+
+repositories { mavenCentral() }
+
+configure<JavaPluginExtension> {
+  sourceCompatibility = JavaVersion.VERSION_17
+  targetCompatibility = JavaVersion.VERSION_17
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+  kotlin {
+    explicitApi()
+    // skip metadata version check, as Spring 7 / Spring Boot 4 is
+    // compiled against a newer version of Kotlin
+    compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict", "-Xskip-metadata-version-check")
+    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+    compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+  }
+}
+
+dependencies {
+  implementation(libs.springboot4.starter)
+  implementation(libs.springboot4.starter.actuator)
+  implementation(libs.springboot4.starter.aspectj)
+  implementation(libs.springboot4.starter.graphql)
+  implementation(libs.springboot4.starter.jdbc)
+  implementation(libs.springboot4.starter.quartz)
+  implementation(libs.springboot4.starter.security)
+  implementation(libs.springboot4.starter.web)
+  implementation(libs.springboot4.starter.webflux)
+  implementation(libs.springboot4.starter.websocket)
+  implementation(libs.springboot4.starter.restclient)
+  implementation(libs.springboot4.starter.webclient)
+  implementation(Config.Libs.aspectj)
+  implementation(Config.Libs.kotlinReflect)
+  implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
+  implementation(projects.sentrySpringBoot4Starter)
+  implementation(projects.sentryLogback)
+  implementation(projects.sentryGraphql22)
+  implementation(projects.sentryQuartz)
+  implementation(projects.sentryAsyncProfiler)
+  implementation(projects.sentryOpentelemetry.sentryOpentelemetryOtlpSpring)
+
+  // database query tracing
+  implementation(projects.sentryJdbc)
+  runtimeOnly(libs.hsqldb)
+
+  testImplementation(kotlin(Config.kotlinStdLib))
+  testImplementation(projects.sentry)
+  testImplementation(projects.sentrySystemTestSupport)
+  testImplementation(libs.apollo3.kotlin)
+  testImplementation(libs.kotlin.test.junit)
+  testImplementation(libs.slf4j2.api)
+  testImplementation(libs.springboot4.starter.test) {
+    exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
+  }
+  testImplementation("ch.qos.logback:logback-classic:1.5.16")
+  testImplementation("ch.qos.logback:logback-core:1.5.16")
+}
+
+dependencyManagement { imports { mavenBom(libs.otel.instrumentation.bom.get().toString()) } }
+
+configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
+
+tasks.register<Test>("systemTest").configure {
+  group = "verification"
+  description = "Runs the System tests"
+
+  outputs.upToDateWhen { false }
+
+  maxParallelForks = 1
+
+  // Cap JVM args per test
+  minHeapSize = "128m"
+  maxHeapSize = "1g"
+
+  filter { includeTestsMatching("io.sentry.systemtest*") }
+}
+
+tasks.named("test").configure {
+  require(this is Test)
+
+  filter { excludeTestsMatching("io.sentry.systemtest.*") }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CustomEventProcessor.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CustomEventProcessor.java
new file mode 100644
index 00000000000..14df61c652f
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CustomEventProcessor.java
@@ -0,0 +1,35 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import io.sentry.EventProcessor;
+import io.sentry.Hint;
+import io.sentry.SentryEvent;
+import io.sentry.protocol.SentryRuntime;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.boot.SpringBootVersion;
+import org.springframework.stereotype.Component;
+
+/**
+ * Custom {@link EventProcessor} implementation lets modifying {@link SentryEvent}s before they are
+ * sent to Sentry.
+ */
+@Component
+public class CustomEventProcessor implements EventProcessor {
+  private final String springBootVersion;
+
+  public CustomEventProcessor(String springBootVersion) {
+    this.springBootVersion = springBootVersion;
+  }
+
+  public CustomEventProcessor() {
+    this(SpringBootVersion.getVersion());
+  }
+
+  @Override
+  public @NotNull SentryEvent process(@NotNull SentryEvent event, @NotNull Hint hint) {
+    final SentryRuntime runtime = new SentryRuntime();
+    runtime.setVersion(springBootVersion);
+    runtime.setName("Spring Boot");
+    event.getContexts().setRuntime(runtime);
+    return event;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CustomJob.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CustomJob.java
new file mode 100644
index 00000000000..6e6df9b2e2a
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CustomJob.java
@@ -0,0 +1,25 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import io.sentry.spring7.checkin.SentryCheckIn;
+import io.sentry.spring7.tracing.SentryTransaction;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+
+/**
+ * {@link SentryTransaction} added on the class level, creates transaction around each method
+ * execution of every method of the annotated class.
+ */
+@Component
+@SentryTransaction(operation = "scheduled")
+public class CustomJob {
+
+  private static final Logger LOGGER = LoggerFactory.getLogger(CustomJob.class);
+
+  @SentryCheckIn("monitor_slug_1")
+  //  @Scheduled(fixedRate = 3 * 60 * 1000L)
+  void execute() throws InterruptedException {
+    LOGGER.info("Executing scheduled job");
+    Thread.sleep(2000L);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/DistributedTracingController.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/DistributedTracingController.java
new file mode 100644
index 00000000000..85e79ee1df5
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/DistributedTracingController.java
@@ -0,0 +1,49 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import java.nio.charset.Charset;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpHeaders;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.client.RestClient;
+
+@RestController
+@RequestMapping("/tracing/")
+public class DistributedTracingController {
+  private static final Logger LOGGER = LoggerFactory.getLogger(DistributedTracingController.class);
+  private final RestClient restClient;
+
+  public DistributedTracingController(RestClient restClient) {
+    this.restClient = restClient;
+  }
+
+  @GetMapping("{id}")
+  Person person(@PathVariable Long id) {
+    return restClient
+        .get()
+        .uri("http://localhost:8080/person/{id}", id)
+        .header(
+            HttpHeaders.AUTHORIZATION,
+            "Basic " + HttpHeaders.encodeBasicAuth("user", "password", Charset.defaultCharset()))
+        .retrieve()
+        .body(Person.class);
+  }
+
+  @PostMapping
+  Person create(@RequestBody Person person) {
+    return restClient
+        .post()
+        .uri("http://localhost:8080/person/")
+        .body(person)
+        .header(
+            HttpHeaders.AUTHORIZATION,
+            "Basic " + HttpHeaders.encodeBasicAuth("user", "password", Charset.defaultCharset()))
+        .retrieve()
+        .body(Person.class);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/MetricController.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/MetricController.java
new file mode 100644
index 00000000000..e980d676d2b
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/MetricController.java
@@ -0,0 +1,35 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import io.sentry.Sentry;
+import io.sentry.metrics.MetricsUnit;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/metric/")
+public class MetricController {
+  private static final Logger LOGGER = LoggerFactory.getLogger(MetricController.class);
+
+  @GetMapping("count")
+  String count() {
+    Sentry.metrics().count("countMetric");
+    return "count metric increased";
+  }
+
+  @GetMapping("gauge/{value}")
+  String gauge(@PathVariable("value") Long value) {
+    Sentry.metrics().gauge("memory.free", value.doubleValue(), MetricsUnit.Information.BYTE);
+    return "gauge metric tracked";
+  }
+
+  @GetMapping("distribution/{value}")
+  String distribution(@PathVariable("value") Long value) {
+    Sentry.metrics()
+        .distribution("distributionMetric", value.doubleValue(), MetricsUnit.Duration.MILLISECOND);
+    return "distribution metric tracked";
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/Person.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/Person.java
new file mode 100644
index 00000000000..8d8bc4bee75
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/Person.java
@@ -0,0 +1,24 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+public class Person {
+  private final String firstName;
+  private final String lastName;
+
+  public Person(String firstName, String lastName) {
+    this.firstName = firstName;
+    this.lastName = lastName;
+  }
+
+  public String getFirstName() {
+    return firstName;
+  }
+
+  public String getLastName() {
+    return lastName;
+  }
+
+  @Override
+  public String toString() {
+    return "Person{" + "firstName='" + firstName + '\'' + ", lastName='" + lastName + '\'' + '}';
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/PersonController.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/PersonController.java
new file mode 100644
index 00000000000..5603255334b
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/PersonController.java
@@ -0,0 +1,51 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import io.sentry.ISpan;
+import io.sentry.Sentry;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/person/")
+public class PersonController {
+  private final PersonService personService;
+  private static final Logger LOGGER = LoggerFactory.getLogger(PersonController.class);
+
+  public PersonController(PersonService personService) {
+    this.personService = personService;
+  }
+
+  @GetMapping("{id}")
+  Person person(@PathVariable Long id) {
+    Sentry.addFeatureFlag("transaction-feature-flag", true);
+    ISpan currentSpan = Sentry.getSpan();
+    ISpan sentrySpan = currentSpan.startChild("spanCreatedThroughSentryApi");
+    try {
+      Sentry.logger().warn("warn Sentry logging");
+      Sentry.logger().error("error Sentry logging");
+      Sentry.logger().info("hello %s %s", "there", "world!");
+      Sentry.addFeatureFlag("my-feature-flag", true);
+      LOGGER.error("Trying person with id={}", id, new RuntimeException("error while loading"));
+      throw new IllegalArgumentException("Something went wrong [id=" + id + "]");
+    } finally {
+      sentrySpan.finish();
+    }
+  }
+
+  @PostMapping
+  Person create(@RequestBody Person person) {
+    ISpan currentSpan = Sentry.getSpan();
+    ISpan sentrySpan = currentSpan.startChild("spanCreatedThroughSentryApi");
+    try {
+      return personService.create(person);
+    } finally {
+      sentrySpan.finish();
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/PersonService.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/PersonService.java
new file mode 100644
index 00000000000..947a82435d4
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/PersonService.java
@@ -0,0 +1,41 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import io.sentry.ISpan;
+import io.sentry.Sentry;
+import io.sentry.spring7.tracing.SentrySpan;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.stereotype.Service;
+
+/**
+ * {@link SentrySpan} can be added either on the class or the method to create spans around method
+ * executions.
+ */
+@Service
+@SentrySpan
+public class PersonService {
+  private static final Logger LOGGER = LoggerFactory.getLogger(PersonService.class);
+
+  private final JdbcTemplate jdbcTemplate;
+  private int createCount = 0;
+
+  public PersonService(JdbcTemplate jdbcTemplate) {
+    this.jdbcTemplate = jdbcTemplate;
+  }
+
+  Person create(Person person) {
+    createCount++;
+    final ISpan span = Sentry.getSpan();
+    if (span != null) {
+      span.setMeasurement("create_count", createCount);
+    }
+
+    jdbcTemplate.update(
+        "insert into person (firstName, lastName) values (?, ?)",
+        person.getFirstName(),
+        person.getLastName());
+
+    return person;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SecurityConfiguration.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SecurityConfiguration.java
new file mode 100644
index 00000000000..69d578f2d89
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SecurityConfiguration.java
@@ -0,0 +1,41 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import org.jetbrains.annotations.NotNull;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.security.core.userdetails.UserDetails;
+import org.springframework.security.crypto.factory.PasswordEncoderFactories;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.security.provisioning.InMemoryUserDetailsManager;
+import org.springframework.security.web.SecurityFilterChain;
+
+@Configuration
+public class SecurityConfiguration {
+
+  // this API is meant to be consumed by non-browser clients thus the CSRF protection is not needed.
+  @SuppressWarnings({"lgtm[java/spring-disabled-csrf-protection]", "removal"})
+  @Bean
+  public SecurityFilterChain filterChain(final @NotNull HttpSecurity http) throws Exception {
+    return http.csrf((csrf) -> csrf.disable())
+        .authorizeHttpRequests((r) -> r.anyRequest().authenticated())
+        .httpBasic((h) -> {})
+        .build();
+  }
+
+  @Bean
+  public @NotNull InMemoryUserDetailsManager userDetailsService() {
+    final PasswordEncoder encoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();
+
+    final UserDetails user =
+        User.builder()
+            .passwordEncoder(encoder::encode)
+            .username("user")
+            .password("password")
+            .roles("USER")
+            .build();
+
+    return new InMemoryUserDetailsManager(user);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SentryDemoApplication.java
new file mode 100644
index 00000000000..b4c58c4882e
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SentryDemoApplication.java
@@ -0,0 +1,81 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import static io.sentry.quartz.SentryJobListener.SENTRY_SLUG_KEY;
+
+import io.sentry.Sentry;
+import io.sentry.SentryOptions;
+import io.sentry.opentelemetry.otlp.OpenTelemetryOtlpEventProcessor;
+import io.sentry.samples.spring.boot4.otlp.quartz.SampleJob;
+import java.util.Collections;
+import org.quartz.JobDetail;
+import org.quartz.SimpleTrigger;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.restclient.RestTemplateBuilder;
+import org.springframework.context.annotation.Bean;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
+import org.springframework.scheduling.quartz.JobDetailFactoryBean;
+import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.reactive.function.client.WebClient;
+
+@SpringBootApplication
+@EnableScheduling
+public class SentryDemoApplication {
+  public static void main(String[] args) {
+    SpringApplication.run(SentryDemoApplication.class, args);
+  }
+
+  @Bean
+  RestTemplate restTemplate(RestTemplateBuilder builder) {
+    return builder.build();
+  }
+
+  @Bean
+  WebClient webClient(WebClient.Builder builder) {
+    return builder.build();
+  }
+
+  @Bean
+  RestClient restClient(RestClient.Builder builder) {
+    return builder.build();
+  }
+
+  @Bean
+  public JobDetailFactoryBean jobDetail() {
+    JobDetailFactoryBean jobDetailFactory = new JobDetailFactoryBean();
+    jobDetailFactory.setJobClass(SampleJob.class);
+    jobDetailFactory.setDurability(true);
+    jobDetailFactory.setJobDataAsMap(
+        Collections.singletonMap(SENTRY_SLUG_KEY, "monitor_slug_job_detail"));
+    return jobDetailFactory;
+  }
+
+  @Bean
+  public SimpleTriggerFactoryBean trigger(JobDetail job) {
+    SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
+    trigger.setJobDetail(job);
+    trigger.setRepeatInterval(2 * 60 * 1000); // every two minutes
+    trigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
+    trigger.setJobDataAsMap(
+        Collections.singletonMap(SENTRY_SLUG_KEY, "monitor_slug_simple_trigger"));
+    return trigger;
+  }
+
+  @Bean
+  public CronTriggerFactoryBean cronTrigger(JobDetail job) {
+    CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
+    trigger.setJobDetail(job);
+    trigger.setCronExpression("0 0/5 * ? * *"); // every five minutes
+    return trigger;
+  }
+
+  @Bean
+  public Sentry.OptionsConfiguration<SentryOptions> sentryOptionsCustomization() {
+    return options -> {
+      options.addEventProcessor(new OpenTelemetryOtlpEventProcessor());
+    };
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/Todo.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/Todo.java
new file mode 100644
index 00000000000..39be54cfc7f
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/Todo.java
@@ -0,0 +1,25 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+public class Todo {
+  private final Long id;
+  private final String title;
+  private final boolean completed;
+
+  public Todo(Long id, String title, boolean completed) {
+    this.id = id;
+    this.title = title;
+    this.completed = completed;
+  }
+
+  public Long getId() {
+    return id;
+  }
+
+  public String getTitle() {
+    return title;
+  }
+
+  public boolean isCompleted() {
+    return completed;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/TodoController.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/TodoController.java
new file mode 100644
index 00000000000..b083e6c1f88
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/TodoController.java
@@ -0,0 +1,57 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import io.sentry.reactor.SentryReactorUtils;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Hooks;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+
+@RestController
+public class TodoController {
+  private final RestTemplate restTemplate;
+  private final WebClient webClient;
+  private final RestClient restClient;
+
+  public TodoController(RestTemplate restTemplate, WebClient webClient, RestClient restClient) {
+    this.restTemplate = restTemplate;
+    this.webClient = webClient;
+    this.restClient = restClient;
+  }
+
+  @GetMapping("/todo/{id}")
+  Todo todo(@PathVariable Long id) {
+    return restTemplate.getForObject(
+        "https://jsonplaceholder.typicode.com/todos/{id}", Todo.class, id);
+  }
+
+  @GetMapping("/todo-webclient/{id}")
+  Todo todoWebClient(@PathVariable Long id) {
+    Hooks.enableAutomaticContextPropagation();
+    return SentryReactorUtils.withSentry(
+            Mono.just(true)
+                .publishOn(Schedulers.boundedElastic())
+                .flatMap(
+                    x ->
+                        webClient
+                            .get()
+                            .uri("https://jsonplaceholder.typicode.com/todos/{id}", id)
+                            .retrieve()
+                            .bodyToMono(Todo.class)
+                            .map(response -> response)))
+        .block();
+  }
+
+  @GetMapping("/todo-restclient/{id}")
+  Todo todoRestClient(@PathVariable Long id) {
+    return restClient
+        .get()
+        .uri("https://jsonplaceholder.typicode.com/todos/{id}", id)
+        .retrieve()
+        .body(Todo.class);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/AssigneeController.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/AssigneeController.java
new file mode 100644
index 00000000000..ef4afb1a6f6
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/AssigneeController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot4.otlp.graphql;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.graphql.data.method.annotation.BatchMapping;
+import org.springframework.stereotype.Controller;
+import reactor.core.publisher.Mono;
+
+@Controller
+public class AssigneeController {
+
+  @BatchMapping(typeName = "Task", field = "assignee")
+  public Mono<Map<ProjectController.Task, ProjectController.Assignee>> assignee(
+      final @NotNull Set<ProjectController.Task> tasks) {
+    return Mono.fromCallable(
+        () -> {
+          final @NotNull Map<ProjectController.Task, ProjectController.Assignee> map =
+              new HashMap<>();
+          for (final @NotNull ProjectController.Task task : tasks) {
+            if ("Acrash".equalsIgnoreCase(task.assigneeId)) {
+              throw new RuntimeException("Causing an error while loading assignee");
+            }
+            if (task.assigneeId != null) {
+              map.put(
+                  task, new ProjectController.Assignee(task.assigneeId, "Name" + task.assigneeId));
+            }
+          }
+
+          return map;
+        });
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/GreetingController.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/GreetingController.java
new file mode 100644
index 00000000000..c1d2a9f9150
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/GreetingController.java
@@ -0,0 +1,17 @@
+package io.sentry.samples.spring.boot4.otlp.graphql;
+
+import org.springframework.graphql.data.method.annotation.Argument;
+import org.springframework.graphql.data.method.annotation.QueryMapping;
+import org.springframework.stereotype.Controller;
+
+@Controller
+public class GreetingController {
+
+  @QueryMapping
+  public String greeting(final @Argument String name) {
+    if ("crash".equalsIgnoreCase(name)) {
+      throw new RuntimeException("causing an error for " + name);
+    }
+    return "Hello " + name + "!";
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/ProjectController.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/ProjectController.java
new file mode 100644
index 00000000000..7ec97bc12f2
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/ProjectController.java
@@ -0,0 +1,140 @@
+package io.sentry.samples.spring.boot4.otlp.graphql;
+
+import java.nio.file.NoSuchFileException;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.graphql.data.method.annotation.Argument;
+import org.springframework.graphql.data.method.annotation.MutationMapping;
+import org.springframework.graphql.data.method.annotation.QueryMapping;
+import org.springframework.graphql.data.method.annotation.SchemaMapping;
+import org.springframework.graphql.data.method.annotation.SubscriptionMapping;
+import org.springframework.stereotype.Controller;
+import reactor.core.publisher.Flux;
+
+@Controller
+public class ProjectController {
+
+  @QueryMapping
+  public Project project(final @Argument String slug) throws Exception {
+    if ("crash".equalsIgnoreCase(slug) || "projectcrash".equalsIgnoreCase(slug)) {
+      throw new RuntimeException("causing a project error for " + slug);
+    }
+    if ("notfound".equalsIgnoreCase(slug)) {
+      throw new IllegalStateException("not found");
+    }
+    if ("nofile".equals(slug)) {
+      throw new NoSuchFileException("no such file");
+    }
+    Project project = new Project();
+    project.slug = slug;
+    return project;
+  }
+
+  @SchemaMapping(typeName = "Project", field = "status")
+  public ProjectStatus projectStatus(final Project project) {
+    if ("crash".equalsIgnoreCase(project.slug) || "statuscrash".equalsIgnoreCase(project.slug)) {
+      throw new RuntimeException("causing a project status error for " + project.slug);
+    }
+    return ProjectStatus.COMMUNITY;
+  }
+
+  @MutationMapping
+  public String addProject(@Argument String slug) {
+    if ("crash".equalsIgnoreCase(slug) || "addprojectcrash".equalsIgnoreCase(slug)) {
+      throw new RuntimeException("causing a project add error for " + slug);
+    }
+    return UUID.randomUUID().toString();
+  }
+
+  @QueryMapping
+  public List<Task> tasks(final @Argument String projectSlug) {
+    List<Task> tasks = new ArrayList<>();
+    tasks.add(new Task("T1", "Create a new API", "A3", "C3"));
+    tasks.add(new Task("T2", "Update dependencies", "A1", "C1"));
+    tasks.add(new Task("T3", "Document API", "A1", "C1"));
+    tasks.add(new Task("T4", "Merge community PRs", "A2", "C2"));
+    tasks.add(new Task("T5", "Plan more work", null, null));
+    if ("crash".equalsIgnoreCase(projectSlug)) {
+      tasks.add(new Task("T6", "Fix crash", "Acrash", "Ccrash"));
+    }
+    return tasks;
+  }
+
+  @SubscriptionMapping
+  public Flux<Task> notifyNewTask(@Argument String projectSlug) {
+    if ("crash".equalsIgnoreCase(projectSlug)) {
+      throw new RuntimeException("causing error for subscription");
+    }
+    if ("fluxerror".equalsIgnoreCase(projectSlug)) {
+      return Flux.error(new RuntimeException("causing flux error for subscription"));
+    }
+    final String assigneeId = "assigneecrash".equalsIgnoreCase(projectSlug) ? "Acrash" : "A1";
+    final String creatorId = "creatorcrash".equalsIgnoreCase(projectSlug) ? "Ccrash" : "C1";
+    final @NotNull AtomicInteger counter = new AtomicInteger(1000);
+    return Flux.interval(Duration.ofSeconds(1))
+        .map(
+            num -> {
+              int i = counter.incrementAndGet();
+              if ("produceerror".equalsIgnoreCase(projectSlug) && i % 2 == 0) {
+                throw new RuntimeException("causing produce error for subscription");
+              }
+              return new Task("T" + i, "A new task arrived ", assigneeId, creatorId);
+            });
+  }
+
+  public static class Task {
+    public String id;
+    public String name;
+    public String assigneeId;
+    public String creatorId;
+
+    public Task(
+        final String id, final String name, final String assigneeId, final String creatorId) {
+      this.id = id;
+      this.name = name;
+      this.assigneeId = assigneeId;
+      this.creatorId = creatorId;
+    }
+
+    @Override
+    public String toString() {
+      return "Task{id=" + id + "}";
+    }
+  }
+
+  public static class Assignee {
+    public String id;
+    public String name;
+
+    public Assignee(final String id, final String name) {
+      this.id = id;
+      this.name = name;
+    }
+  }
+
+  public static class Creator {
+    public String id;
+    public String name;
+
+    public Creator(final String id, final String name) {
+      this.id = id;
+      this.name = name;
+    }
+  }
+
+  public static class Project {
+    public String slug;
+  }
+
+  public enum ProjectStatus {
+    ACTIVE,
+    COMMUNITY,
+    INCUBATING,
+    ATTIC,
+    EOL;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/TaskCreatorController.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/TaskCreatorController.java
new file mode 100644
index 00000000000..94314cbfcac
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/graphql/TaskCreatorController.java
@@ -0,0 +1,50 @@
+package io.sentry.samples.spring.boot4.otlp.graphql;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import org.dataloader.BatchLoaderEnvironment;
+import org.dataloader.DataLoader;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.graphql.data.method.annotation.SchemaMapping;
+import org.springframework.graphql.execution.BatchLoaderRegistry;
+import org.springframework.stereotype.Controller;
+import reactor.core.publisher.Mono;
+
+@Controller
+class TaskCreatorController {
+
+  public TaskCreatorController(final BatchLoaderRegistry batchLoaderRegistry) {
+    // using mapped BatchLoader to not have to deal with correct ordering of items
+    batchLoaderRegistry
+        .forTypePair(String.class, ProjectController.Creator.class)
+        .withOptions((builder) -> builder.setBatchingEnabled(true))
+        .registerMappedBatchLoader(
+            (Set<String> keys, BatchLoaderEnvironment env) -> {
+              return Mono.fromCallable(
+                  () -> {
+                    final @NotNull Map<String, ProjectController.Creator> map = new HashMap<>();
+                    for (String key : keys) {
+                      if ("Ccrash".equalsIgnoreCase(key)) {
+                        throw new RuntimeException("Causing an error while loading creator");
+                      }
+                      map.put(key, new ProjectController.Creator(key, "Name" + key));
+                    }
+
+                    return map;
+                  });
+            });
+  }
+
+  @SchemaMapping(typeName = "Task")
+  public @Nullable CompletableFuture<ProjectController.Creator> creator(
+      final ProjectController.Task task,
+      final DataLoader<String, ProjectController.Creator> dataLoader) {
+    if (task.creatorId == null) {
+      return null;
+    }
+    return dataLoader.load(task.creatorId);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/quartz/SampleJob.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/quartz/SampleJob.java
new file mode 100644
index 00000000000..db143d90eb6
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/quartz/SampleJob.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot4.otlp.quartz;
+
+import org.quartz.Job;
+import org.quartz.JobExecutionContext;
+import org.quartz.JobExecutionException;
+import org.springframework.stereotype.Component;
+
+@Component
+public class SampleJob implements Job {
+
+  public void execute(JobExecutionContext context) throws JobExecutionException {
+    System.out.println("running job");
+    try {
+      Thread.sleep(15000);
+    } catch (InterruptedException e) {
+      throw new RuntimeException(e);
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/application.properties
new file mode 100644
index 00000000000..43c0bd18c08
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/application.properties
@@ -0,0 +1,53 @@
+# NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in your Sentry project/dashboard
+sentry.dsn=https://502f25099c204a2fbf4cb16edc5975d1@o447951.ingest.sentry.io/5428563
+sentry.send-default-pii=true
+sentry.max-request-body-size=medium
+# Sentry Spring Boot integration allows more fine-grained SentryOptions configuration
+sentry.max-breadcrumbs=150
+# Logback integration configuration options
+sentry.logging.minimum-event-level=info
+sentry.logging.minimum-breadcrumb-level=debug
+# Performance configuration
+#sentry.traces-sample-rate=1.0
+sentry.ignored-checkins=ignored_monitor_slug_1,ignored_monitor_slug_2
+sentry.debug=true
+sentry.graphql.ignored-error-types=SOME_ERROR,ANOTHER_ERROR
+sentry.enable-backpressure-handling=true
+sentry.enable-spotlight=true
+sentry.enablePrettySerializationOutput=false
+sentry.in-app-includes="io.sentry.samples"
+sentry.logs.enabled=true
+sentry.profile-session-sample-rate=1.0
+sentry.profiling-traces-dir-path=tmp/sentry/profiling-traces
+sentry.profile-lifecycle=TRACE
+
+# Uncomment and set to true to enable aot compatibility
+# This flag disables all AOP related features (i.e. @SentryTransaction, @SentrySpan)
+# to successfully compile to GraalVM
+# sentry.enable-aot-compatibility=false
+
+# Database configuration
+spring.datasource.url=jdbc:p6spy:hsqldb:mem:testdb
+spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver
+spring.datasource.username=sa
+spring.datasource.password=
+spring.graphql.graphiql.enabled=true
+spring.graphql.websocket.path=/graphql
+spring.quartz.job-store-type=memory
+
+# OTEL configuration
+# Use Sentry propagator to propagate sentry-trace and baggage headers
+otel.propagators=tracecontext,baggage,sentry
+otel.logs.exporter=none
+otel.metrics.exporter=none
+# OTLP traces exporter configuration
+# Use both otlp and logging exporters - logging prints spans to console for debugging
+otel.traces.exporter=otlp,logging
+otel.exporter.otlp.traces.endpoint=https://o447951.ingest.us.sentry.io/api/5428563/integration/otlp/v1/traces
+otel.exporter.otlp.traces.protocol=http/protobuf
+otel.exporter.otlp.traces.headers=x-sentry-auth=sentry sentry_key=502f25099c204a2fbf4cb16edc5975d1
+
+# Debug logging for OTel
+logging.level.io.opentelemetry=DEBUG
+logging.level.io.opentelemetry.exporter=DEBUG
+logging.level.io.opentelemetry.sdk.trace.export=DEBUG
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/graphql/schema.graphqls b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/graphql/schema.graphqls
new file mode 100644
index 00000000000..aeea62357bd
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/graphql/schema.graphqls
@@ -0,0 +1,68 @@
+type Query {
+    greeting(name: String! = "Spring"): String!
+    project(slug: ID!): Project
+    tasks(projectSlug: ID!): [Task]
+}
+
+type Mutation {
+    addProject(slug: ID!): String!
+}
+
+type Subscription {
+    notifyNewTask(projectSlug: ID!): Task
+}
+
+""" A Project in the Spring portfolio """
+type Project {
+    """ Unique string id used in URLs """
+    slug: ID!
+    """ Project name """
+    name: String
+    """ Current support status """
+    status: ProjectStatus!
+}
+
+""" A task """
+type Task {
+    """ ID """
+    id: String!
+    """ Name """
+    name: String!
+    """ ID of the Assignee """
+    assigneeId: String
+    """ Assignee """
+    assignee: Assignee
+    """ ID of the Creator """
+    creatorId: String
+    """ Creator """
+    creator: Creator
+}
+
+""" An Assignee """
+type Assignee {
+    """ ID """
+    id: String!
+    """ Name """
+    name: String!
+}
+
+""" An Creator """
+type Creator {
+    """ ID """
+    id: String!
+    """ Name """
+    name: String!
+}
+
+enum ProjectStatus {
+    """ Actively supported by the Spring team """
+    ACTIVE
+    """ Supported by the community """
+    COMMUNITY
+    """ Prototype, not officially supported yet  """
+    INCUBATING
+    """ Project being retired, in maintenance mode """
+    ATTIC
+    """ End-Of-Lifed """
+    EOL
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/quartz.properties b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/quartz.properties
new file mode 100644
index 00000000000..6e302ce765a
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/quartz.properties
@@ -0,0 +1 @@
+org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/schema.sql b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/schema.sql
new file mode 100644
index 00000000000..7ca8a5cbf42
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/schema.sql
@@ -0,0 +1,5 @@
+CREATE TABLE person (
+   id INTEGER IDENTITY PRIMARY KEY,
+   firstName VARCHAR(50) NOT NULL,
+   lastName VARCHAR(50) NOT NULL
+);
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/DummyTest.kt b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/DummyTest.kt
new file mode 100644
index 00000000000..6f762b7e453
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/DummyTest.kt
@@ -0,0 +1,12 @@
+package io.sentry
+
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+class DummyTest {
+  @Test
+  fun `the only test`() {
+    // only needed to have more than 0 tests and not fail the build
+    assertTrue(true)
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/DistributedTracingSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/DistributedTracingSystemTest.kt
new file mode 100644
index 00000000000..3cd16003024
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/DistributedTracingSystemTest.kt
@@ -0,0 +1,197 @@
+package io.sentry.systemtest
+
+import io.sentry.protocol.SentryId
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotEquals
+import org.junit.Before
+
+class DistributedTracingSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `get person distributed tracing`() {
+    val traceId = SentryId()
+    val restClient = testHelper.restClient
+    restClient.getPersonDistributedTracing(
+      1L,
+      mapOf(
+        "sentry-trace" to "$traceId-424cffc8f94feeee-1",
+        "baggage" to
+          "sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=$traceId,sentry-transaction=HTTP%20GET",
+      ),
+    )
+    assertEquals(500, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      transaction.transaction == "GET /tracing/{id}" &&
+        testHelper.doesTransactionHaveTraceId(transaction, traceId.toString())
+    }
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      transaction.transaction == "GET /person/{id}" &&
+        testHelper.doesTransactionHaveTraceId(transaction, traceId.toString())
+    }
+  }
+
+  @Test
+  fun `get person distributed tracing with sampled false`() {
+    val traceId = SentryId()
+    val restClient = testHelper.restClient
+    restClient.getPersonDistributedTracing(
+      1L,
+      mapOf(
+        "sentry-trace" to "$traceId-424cffc8f94feeee-0",
+        "baggage" to
+          "sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=false,sentry-trace_id=$traceId,sentry-transaction=HTTP%20GET",
+      ),
+    )
+    assertEquals(500, restClient.lastKnownStatusCode)
+
+    testHelper.ensureNoTransactionReceived { transaction, envelopeHeader ->
+      transaction.transaction == "GET /tracing/{id}"
+    }
+
+    testHelper.ensureNoTransactionReceived { transaction, envelopeHeader ->
+      transaction.transaction == "GET /person/{id}"
+    }
+  }
+
+  @Test
+  fun `get person distributed tracing without sample_rand`() {
+    val traceId = SentryId()
+    val restClient = testHelper.restClient
+    restClient.getPersonDistributedTracing(
+      1L,
+      mapOf(
+        "sentry-trace" to "$traceId-424cffc8f94feeee-1",
+        "baggage" to
+          "sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=$traceId,sentry-transaction=HTTP%20GET",
+      ),
+    )
+    assertEquals(500, restClient.lastKnownStatusCode)
+
+    var sampleRand1: String? = null
+    var sampleRand2: String? = null
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      val matches =
+        transaction.transaction == "GET /tracing/{id}" &&
+          envelopeHeader.traceContext!!.traceId == traceId &&
+          testHelper.doesTransactionHaveTraceId(transaction, traceId.toString())
+
+      if (matches) {
+        testHelper.logObject(envelopeHeader)
+        testHelper.logObject(transaction)
+        sampleRand1 = envelopeHeader.traceContext?.sampleRand
+      }
+
+      matches
+    }
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      val matches =
+        transaction.transaction == "GET /person/{id}" &&
+          envelopeHeader.traceContext!!.traceId == traceId &&
+          testHelper.doesTransactionHaveTraceId(transaction, traceId.toString())
+
+      if (matches) {
+        testHelper.logObject(envelopeHeader)
+        testHelper.logObject(transaction)
+        sampleRand2 = envelopeHeader.traceContext?.sampleRand
+      }
+
+      matches
+    }
+
+    assertEquals(sampleRand1, sampleRand2)
+  }
+
+  @Test
+  fun `get person distributed tracing updates sample_rate on deferred decision`() {
+    val traceId = SentryId()
+    val restClient = testHelper.restClient
+    restClient.getPersonDistributedTracing(
+      1L,
+      mapOf(
+        "sentry-trace" to "$traceId-424cffc8f94feeee",
+        "baggage" to
+          "sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rate=0.5,sentry-trace_id=$traceId,sentry-transaction=HTTP%20GET",
+      ),
+    )
+    assertEquals(500, restClient.lastKnownStatusCode)
+
+    var sampleRate1: String? = null
+    var sampleRate2: String? = null
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      val matches =
+        transaction.transaction == "GET /tracing/{id}" &&
+          envelopeHeader.traceContext!!.traceId == traceId &&
+          testHelper.doesTransactionHaveTraceId(transaction, traceId.toString())
+
+      if (matches) {
+        testHelper.logObject(envelopeHeader)
+        testHelper.logObject(transaction)
+        sampleRate1 = envelopeHeader.traceContext?.sampleRate
+      }
+
+      matches
+    }
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      val matches =
+        transaction.transaction == "GET /person/{id}" &&
+          envelopeHeader.traceContext!!.traceId == traceId &&
+          testHelper.doesTransactionHaveTraceId(transaction, traceId.toString())
+
+      if (matches) {
+        testHelper.logObject(envelopeHeader)
+        testHelper.logObject(transaction)
+        sampleRate2 = envelopeHeader.traceContext?.sampleRate
+      }
+
+      matches
+    }
+
+    assertEquals(sampleRate1, sampleRate2)
+    assertNotEquals(sampleRate1, "0.5")
+  }
+
+  @Test
+  fun `create person distributed tracing`() {
+    val traceId = SentryId()
+    val restClient = testHelper.restClient
+    val person = Person("firstA", "lastB")
+    val returnedPerson =
+      restClient.createPersonDistributedTracing(
+        person,
+        mapOf(
+          "sentry-trace" to "$traceId-424cffc8f94feeee-1",
+          "baggage" to
+            "sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=$traceId,sentry-transaction=HTTP%20GET",
+        ),
+      )
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    assertEquals(person.firstName, returnedPerson!!.firstName)
+    assertEquals(person.lastName, returnedPerson!!.lastName)
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      transaction.transaction == "POST /tracing/" &&
+        testHelper.doesTransactionHaveTraceId(transaction, traceId.toString())
+    }
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      transaction.transaction == "POST /person/" &&
+        testHelper.doesTransactionHaveTraceId(transaction, traceId.toString())
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlGreetingSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlGreetingSystemTest.kt
new file mode 100644
index 00000000000..76a6024decc
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlGreetingSystemTest.kt
@@ -0,0 +1,46 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import org.junit.Before
+
+class GraphqlGreetingSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `greeting works`() {
+    val response = testHelper.graphqlClient.greet("world")
+
+    testHelper.ensureNoErrors(response)
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOpAndDescription(
+        transaction,
+        "graphql",
+        "Query.greeting",
+      )
+    }
+  }
+
+  @Test
+  fun `greeting error`() {
+    val response = testHelper.graphqlClient.greet("crash")
+
+    testHelper.ensureErrorCount(response, 1)
+    testHelper.ensureErrorReceived { error ->
+      error.message?.message?.startsWith("Unresolved RuntimeException for executionId ") ?: false
+    }
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOpAndDescription(
+        transaction,
+        "graphql",
+        "Query.greeting",
+      )
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlProjectSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlProjectSystemTest.kt
new file mode 100644
index 00000000000..fca3956717c
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlProjectSystemTest.kt
@@ -0,0 +1,66 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import org.junit.Before
+
+class GraphqlProjectSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `project query works`() {
+    val response = testHelper.graphqlClient.project("proj-slug")
+
+    testHelper.ensureNoErrors(response)
+    assertEquals("proj-slug", response?.data?.project?.slug)
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOpAndDescription(
+        transaction,
+        "graphql",
+        "Query.project",
+      )
+    }
+  }
+
+  @Test
+  fun `project mutation works`() {
+    val response = testHelper.graphqlClient.addProject("proj-slug")
+
+    testHelper.ensureNoErrors(response)
+    assertNotNull(response?.data?.addProject)
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOpAndDescription(
+        transaction,
+        "graphql",
+        "Mutation.addProject",
+      )
+    }
+  }
+
+  @Test
+  fun `project mutation error`() {
+    val response = testHelper.graphqlClient.addProject("addprojectcrash")
+
+    testHelper.ensureErrorCount(response, 1)
+    assertNull(response?.data?.addProject)
+    testHelper.ensureErrorReceived { error ->
+      error.message?.message?.startsWith("Unresolved RuntimeException for executionId ") ?: false
+    }
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOpAndDescription(
+        transaction,
+        "graphql",
+        "Mutation.addProject",
+      )
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlTaskSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlTaskSystemTest.kt
new file mode 100644
index 00000000000..940709c0778
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/GraphqlTaskSystemTest.kt
@@ -0,0 +1,50 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class GraphqlTaskSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `tasks and assignees query works`() {
+    val response = testHelper.graphqlClient.tasksAndAssignees("project-slug")
+
+    testHelper.ensureNoErrors(response)
+
+    assertEquals(5, response?.data?.tasks?.size)
+
+    val firstTask = response?.data?.tasks?.firstOrNull() ?: throw RuntimeException("no task")
+    assertEquals("T1", firstTask.id)
+    assertEquals("A3", firstTask.assigneeId)
+    assertEquals("A3", firstTask.assignee?.id)
+    assertEquals("C3", firstTask.creatorId)
+    assertEquals("C3", firstTask.creator?.id)
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOpAndDescription(
+        transaction,
+        "graphql",
+        "Query.tasks",
+      ) &&
+        testHelper.doesTransactionContainSpanWithOpAndDescription(
+          transaction,
+          "graphql",
+          "Task.assignee",
+        ) &&
+        testHelper.doesTransactionContainSpanWithOpAndDescription(
+          transaction,
+          "graphql",
+          "Task.creator",
+        )
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
new file mode 100644
index 00000000000..dc2ca2a10ae
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -0,0 +1,49 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class MetricsSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `count metric`() {
+    val restClient = testHelper.restClient
+    assertEquals("count metric increased", restClient.getCountMetric())
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureMetricsReceived { event, header ->
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+    }
+  }
+
+  @Test
+  fun `gauge metric`() {
+    val restClient = testHelper.restClient
+    assertEquals("gauge metric tracked", restClient.getGaugeMetric(14))
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureMetricsReceived { event, header ->
+      testHelper.doesContainMetric(event, "memory.free", "gauge", 14.0)
+    }
+  }
+
+  @Test
+  fun `distribution metric`() {
+    val restClient = testHelper.restClient
+    assertEquals("distribution metric tracked", restClient.getDistributionMetric(23))
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureMetricsReceived { event, header ->
+      testHelper.doesContainMetric(event, "distributionMetric", "distribution", 23.0)
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
new file mode 100644
index 00000000000..362a8577148
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -0,0 +1,96 @@
+package io.sentry.systemtest
+
+import io.sentry.protocol.FeatureFlag
+import io.sentry.protocol.SentryId
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class PersonSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `get person fails`() {
+    val restClient = testHelper.restClient
+    restClient.getPerson(1L)
+    assertEquals(500, restClient.lastKnownStatusCode)
+
+    testHelper.ensureErrorReceived { event ->
+      event.message?.formatted == "Trying person with id=1" &&
+        testHelper.doesEventHaveFlag(event, "my-feature-flag", true)
+    }
+
+    testHelper.ensureErrorReceived { event ->
+      testHelper.doesEventHaveExceptionMessage(event, "Something went wrong [id=1]") &&
+        testHelper.doesEventHaveFlag(event, "my-feature-flag", true)
+    }
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionHave(
+        transaction,
+        op = "http.server",
+        featureFlag = FeatureFlag("flag.evaluation.transaction-feature-flag", true),
+      ) &&
+        testHelper.doesTransactionHaveSpanWith(
+          transaction,
+          op = "spanCreatedThroughSentryApi",
+          featureFlag = FeatureFlag("flag.evaluation.my-feature-flag", true),
+        )
+    }
+
+    Thread.sleep(10000)
+
+    testHelper.ensureLogsReceived { logs, envelopeHeader ->
+      testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
+        testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
+        testHelper.doesContainLogWithBody(logs, "hello there world!")
+    }
+  }
+
+  @Test
+  fun `create person works`() {
+    val restClient = testHelper.restClient
+    val person = Person("firstA", "lastB")
+    val returnedPerson = restClient.createPerson(person)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    assertEquals(person.firstName, returnedPerson!!.firstName)
+    assertEquals(person.lastName, returnedPerson!!.lastName)
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "PersonService.create") &&
+        testHelper.doesTransactionContainSpanWithOpAndDescription(
+          transaction,
+          "db.query",
+          "insert into person (firstName, lastName) values (?, ?)",
+        )
+    }
+  }
+
+  @Test
+  fun `create person starts a profile linked to the transaction`() {
+    var profilerId: SentryId? = null
+    val restClient = testHelper.restClient
+    val person = Person("firstA", "lastB")
+    val returnedPerson = restClient.createPerson(person)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    assertEquals(person.firstName, returnedPerson!!.firstName)
+    assertEquals(person.lastName, returnedPerson!!.lastName)
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      profilerId = transaction.contexts.profile?.profilerId
+      transaction.transaction == "POST /person/"
+    }
+    testHelper.ensureProfileChunkReceived { profileChunk, envelopeHeader ->
+      profileChunk.profilerId == profilerId
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/TodoSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/TodoSystemTest.kt
new file mode 100644
index 00000000000..d34485e1388
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/TodoSystemTest.kt
@@ -0,0 +1,61 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class TodoSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `get todo works`() {
+    val restClient = testHelper.restClient
+    restClient.getTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOpAndDescription(
+        transaction,
+        "http.client",
+        "GET https://jsonplaceholder.typicode.com/todos/1",
+      )
+    }
+  }
+
+  @Test
+  fun `get todo webclient works`() {
+    val restClient = testHelper.restClient
+    restClient.getTodoWebclient(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOpAndDescription(
+        transaction,
+        "http.client",
+        "GET https://jsonplaceholder.typicode.com/todos/1",
+      )
+    }
+  }
+
+  @Test
+  fun `get todo restclient works`() {
+    val restClient = testHelper.restClient
+    restClient.getTodoRestClient(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, envelopeHeader ->
+      testHelper.doesTransactionContainSpanWithOpAndDescription(
+        transaction,
+        "http.client",
+        "GET https://jsonplaceholder.typicode.com/todos/1",
+      )
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/resources/logback.xml b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/resources/logback.xml
new file mode 100644
index 00000000000..a36b8f80f76
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/resources/logback.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE configuration>
+
+<configuration>
+  <import class="ch.qos.logback.classic.encoder.PatternLayoutEncoder"/>
+  <import class="ch.qos.logback.core.ConsoleAppender"/>
+
+  <appender name="STDOUT" class="ConsoleAppender">
+    <encoder class="PatternLayoutEncoder">
+      <pattern>%-4relative [%thread] %-5level %logger{35} -%kvp- %msg %n</pattern>
+    </encoder>
+  </appender>
+
+  <root level="DEBUG">
+    <appender-ref ref="STDOUT"/>
+  </root>
+</configuration>
diff --git a/settings.gradle.kts b/settings.gradle.kts
index fcff35af112..0e9987b4ae4 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -64,6 +64,8 @@ include(
     "sentry-opentelemetry:sentry-opentelemetry-agent",
     "sentry-opentelemetry:sentry-opentelemetry-agentless",
     "sentry-opentelemetry:sentry-opentelemetry-agentless-spring",
+    "sentry-opentelemetry:sentry-opentelemetry-otlp",
+    "sentry-opentelemetry:sentry-opentelemetry-otlp-spring",
     "sentry-quartz",
     "sentry-okhttp",
     "sentry-openfeature",
@@ -74,6 +76,7 @@ include(
     "sentry-ktor-client",
     "sentry-samples:sentry-samples-android",
     "sentry-samples:sentry-samples-console",
+    "sentry-samples:sentry-samples-console-otlp",
     "sentry-samples:sentry-samples-console-opentelemetry-noagent",
     "sentry-samples:sentry-samples-jul",
     "sentry-samples:sentry-samples-ktor-client",
@@ -94,6 +97,7 @@ include(
     "sentry-samples:sentry-samples-spring-boot-4",
     "sentry-samples:sentry-samples-spring-boot-4-opentelemetry",
     "sentry-samples:sentry-samples-spring-boot-4-opentelemetry-noagent",
+    "sentry-samples:sentry-samples-spring-boot-4-otlp",
     "sentry-samples:sentry-samples-spring-boot-4-webflux",
     "sentry-samples:sentry-samples-netflix-dgs",
     "sentry-android-integration-tests:sentry-uitest-android-critical",
diff --git a/test/system-test-runner.py b/test/system-test-runner.py
index 1188e6efbc4..55a1136fbe0 100644
--- a/test/system-test-runner.py
+++ b/test/system-test-runner.py
@@ -733,7 +733,9 @@ def get_available_modules(self) -> List[ModuleConfig]:
             ModuleConfig("sentry-samples-spring-boot-4-opentelemetry-noagent", "false", "true", "false"),
             ModuleConfig("sentry-samples-spring-boot-4-opentelemetry", "true", "true", "false"),
             ModuleConfig("sentry-samples-spring-boot-4-opentelemetry", "true", "false", "false"),
+            ModuleConfig("sentry-samples-spring-boot-4-otlp", "false", "true", "false"),
             ModuleConfig("sentry-samples-console", "false", "true", "false"),
+            ModuleConfig("sentry-samples-console-otlp", "false", "true", "false"),
             ModuleConfig("sentry-samples-console-opentelemetry-noagent", "false", "true", "false"),
             ModuleConfig("sentry-samples-logback", "false", "true", "false"),
             ModuleConfig("sentry-samples-log4j2", "false", "true", "false"),

From c3a7aed04e9d6d4868bb837176593e9418f0ff1b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Mar 2026 11:04:32 +0100
Subject: [PATCH 012/391] build(deps): bump gradle/actions from 5.0.1 to 5.0.2
 (#5131)

Bumps [gradle/actions](https://github.com/gradle/actions) from 5.0.1 to 5.0.2.
- [Release notes](https://github.com/gradle/actions/releases)
- [Commits](https://github.com/gradle/actions/compare/f29f5a9d7b09a7c6b29859002d29d24e1674c884...0723195856401067f7a2779048b490ace7a47d7c)

---
updated-dependencies:
- dependency-name: gradle/actions
  dependency-version: 5.0.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/codeql-analysis.yml               | 2 +-
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 15 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 7d2297ed33a..5ee404e790a 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -39,7 +39,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index ab7e6904c90..6d9766784b5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -37,7 +37,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index c93a2128524..ffd4082904d 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -31,7 +31,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index 9143270b5a1..ca27a0b201a 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
 
       - name: Set up Java
         uses: actions/setup-java@v5
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index 3662f1db3e8..197b5d95659 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -19,7 +19,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index 3ef5d3c52cf..7909b659108 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -20,7 +20,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
 
       - name: Generate Aggregate Javadocs
         run: |
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 4d6b403be65..5796cc0e020 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -38,7 +38,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
@@ -88,7 +88,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index bb867681b59..7df0d8bb65d 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -36,7 +36,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 792583937ba..b1b912c0561 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -36,7 +36,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 017a150155e..41f3829993d 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -33,7 +33,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 8b41af5e846..37c0bef8a9d 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -26,7 +26,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
 
       - name: Build artifacts
         run: make publish
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 2cb073304a9..f31e38baee3 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -56,7 +56,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 3b225ebe684..4f33bd18a84 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -56,7 +56,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index a7da8d3bf7e..7578b7a9c10 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -56,7 +56,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 641b49f6c85..88980099774 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -114,7 +114,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@f29f5a9d7b09a7c6b29859002d29d24e1674c884
+        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 

From a0cbb4a0d7c5495deac611aa932ff468627064e9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Mar 2026 11:05:38 +0100
Subject: [PATCH 013/391] build(deps): bump actions/download-artifact from 7 to
 8 (#5132)

Bumps [actions/download-artifact](https://github.com/actions/download-artifact) from 7 to 8.
- [Release notes](https://github.com/actions/download-artifact/releases)
- [Commits](https://github.com/actions/download-artifact/compare/v7...v8)

---
updated-dependencies:
- dependency-name: actions/download-artifact
  dependency-version: '8'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index b1b912c0561..b8bd19471e9 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -114,7 +114,7 @@ jobs:
           script: echo "Generated AVD snapshot for caching."
 
       - name: Download APK artifact
-        uses: actions/download-artifact@v7
+        uses: actions/download-artifact@v8
         with:
           name: ${{env.APK_ARTIFACT_NAME}}
 

From fc4ec486014351df14cb6d3137ed23560bd201ae Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Mar 2026 11:20:45 +0100
Subject: [PATCH 014/391] build(deps): bump actions/upload-artifact from 6 to 7
 (#5130)

Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 6 to 7.
- [Release notes](https://github.com/actions/upload-artifact/releases)
- [Commits](https://github.com/actions/upload-artifact/compare/v6...v7)

---
updated-dependencies:
- dependency-name: actions/upload-artifact
  dependency-version: '7'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 4 ++--
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 5ee404e790a..d5f326b56bf 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -94,7 +94,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: test-results-AGP${{ matrix.agp }}-Integrations${{ matrix.integrations }}
           path: |
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6d9766784b5..56e832b8e43 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -53,7 +53,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: test-results-build
           path: |
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index b8bd19471e9..77691bfd65b 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -44,7 +44,7 @@ jobs:
         run: make assembleUiTestCriticalRelease
 
       - name: Upload APK artifact
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: ${{env.APK_ARTIFACT_NAME}}
           path: "${{env.BASE_PATH}}/${{env.BUILD_PATH}}/${{env.APK_NAME}}"
@@ -141,7 +141,7 @@ jobs:
 
       - name: Upload Maestro test results
         if: ${{ always() }}
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: maestro-logs-${{ matrix.api-level }}-${{ matrix.arch }}-${{ matrix.target }}
           path: "${{env.BASE_PATH}}/maestro-logs"
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 37c0bef8a9d..7e7774365b9 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -32,7 +32,7 @@ jobs:
         run: make publish
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: ${{ github.sha }}
           if-no-files-found: error
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index f31e38baee3..a6c2d7b48b7 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -150,7 +150,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: test-results-springboot-2-${{ matrix.springboot-version }}
           path: |
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 4f33bd18a84..03232723741 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -150,7 +150,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: test-results-springboot-3-${{ matrix.springboot-version }}
           path: |
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 7578b7a9c10..c82113828cc 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -151,7 +151,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: test-results-springboot-4-${{ matrix.springboot-version }}
           path: |
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 88980099774..4f7929343cc 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -153,7 +153,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: test-results-${{ matrix.sample }}-${{ matrix.agent }}-${{ matrix.agent-auto-init }}-system-test
           path: |

From b35244beb3e187553ad4f49a091791dd1f926ec7 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 2 Mar 2026 10:52:41 +0000
Subject: [PATCH 015/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.13.1 (#5104)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 ++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bf481f1cca3..dba0f4dcdfe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -32,6 +32,12 @@
 
 - Fix crash when unregistering `SystemEventsBroadcastReceiver` with try-catch block. ([#5106](https://github.com/getsentry/sentry-java/pull/5106))
 
+### Dependencies
+
+- Bump Native SDK from v0.12.7 to v0.13.1 ([#5104](https://github.com/getsentry/sentry-java/pull/5104))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0131)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.12.7...0.13.1)
+
 ## 8.33.0
 
 ### Features
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index d283b549895..dd2a471f695 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -151,7 +151,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.12.7" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.1" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 41fa056779d19077af437b92fcc4fa2d546f0677 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Mar 2026 11:56:55 +0100
Subject: [PATCH 016/391] build(deps): bump getsentry/craft from 2.21.7 to
 2.23.1 (#5129)

Bumps [getsentry/craft](https://github.com/getsentry/craft) from 2.21.7 to 2.23.1.
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/41defb379de52e5f0e3943944fa5575b22fb9f92...d4cfac9d25d1fc72c9241e5d22aff559a114e4e9)

---
updated-dependencies:
- dependency-name: getsentry/craft
  dependency-version: 2.23.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 0dd2ea4b92c..df09bf89706 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@41defb379de52e5f0e3943944fa5575b22fb9f92 # v2
+        uses: getsentry/craft@d4cfac9d25d1fc72c9241e5d22aff559a114e4e9 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From 8124101b64493c4107a4fb85979ff6b130c7682f Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Mon, 2 Mar 2026 12:27:33 +0100
Subject: [PATCH 017/391] chore(ai): Add `/create-java-pr` Claude Code skill
 (#5119)

* ci: add create-java-pr Claude Code skill

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* use PR template for Java PRs

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .claude/skills/create-java-pr/SKILL.md | 128 +++++++++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 .claude/skills/create-java-pr/SKILL.md

diff --git a/.claude/skills/create-java-pr/SKILL.md b/.claude/skills/create-java-pr/SKILL.md
new file mode 100644
index 00000000000..7dcb5ea47c3
--- /dev/null
+++ b/.claude/skills/create-java-pr/SKILL.md
@@ -0,0 +1,128 @@
+---
+name: create-java-pr
+description: Create a pull request in sentry-java. Use when asked to "create pr", "prepare pr", "prep pr", "open pr", "ready for pr", "prepare for review", "finalize changes". Handles branch creation, code formatting, API dump, committing, pushing, PR creation, and changelog.
+---
+
+# Create Pull Request (sentry-java)
+
+Prepare local changes and create a pull request for the sentry-java repo.
+
+## Step 1: Ensure Feature Branch
+
+```bash
+git branch --show-current
+```
+
+If on `main` or `master`, create and switch to a new branch:
+
+```bash
+git checkout -b <type>/<short-description>
+```
+
+Derive the branch name from the changes being made. Use `feat/`, `fix/`, `ref/`, etc. matching the commit type conventions.
+
+## Step 2: Format Code and Regenerate API Files
+
+```bash
+./gradlew spotlessApply apiDump
+```
+
+This is **required** before every PR in this repo. It formats all Java/Kotlin code via Spotless and regenerates the `.api` binary compatibility files.
+
+If the command fails, diagnose and fix the issue before continuing.
+
+## Step 3: Commit Changes
+
+Check for uncommitted changes:
+
+```bash
+git status --porcelain
+```
+
+If there are uncommitted changes, invoke the `sentry-skills:commit` skill to stage and commit them following Sentry conventions.
+
+**Important:** When staging, ignore changes that are only relevant for local testing and should not be part of the PR. Common examples:
+
+| Ignore Pattern | Reason |
+|---|---|
+| Hardcoded booleans flipped for testing | Local debug toggles |
+| Sample app config changes (`sentry-samples/`) | Local testing configuration |
+| `.env` or credentials files | Secrets |
+
+Restore these files before committing:
+
+```bash
+git checkout -- <file-to-restore>
+```
+
+## Step 4: Push the Branch
+
+```bash
+git push -u origin HEAD
+```
+
+If the push fails due to diverged history, ask the user how to proceed rather than force-pushing.
+
+## Step 5: Create PR
+
+Invoke the `sentry-skills:create-pr` skill to create a draft PR. When providing the PR body, use the repo's PR template structure from `.github/pull_request_template.md`:
+
+```
+## :scroll: Description
+<Describe the changes in detail>
+
+## :bulb: Motivation and Context
+<Why is this change required? What problem does it solve?>
+
+## :green_heart: How did you test it?
+<Describe how you tested>
+
+## :pencil: Checklist
+- [ ] I added GH Issue ID _&_ Linear ID
+- [ ] I added tests to verify the changes.
+- [ ] No new PII added or SDK only sends newly added PII if `sendDefaultPII` is enabled.
+- [ ] I updated the docs if needed.
+- [ ] I updated the wizard if needed.
+- [ ] Review from the native team if needed.
+- [ ] No breaking change or entry added to the changelog.
+- [ ] No breaking change for hybrid SDKs or communicated to hybrid SDKs.
+
+## :crystal_ball: Next steps
+```
+
+Fill in each section based on the changes being PR'd. Check any checklist items that apply.
+
+Then continue to Step 6.
+
+## Step 6: Update Changelog
+
+After the PR is created, add an entry to `CHANGELOG.md` under the `## Unreleased` section.
+
+### Determine the subsection
+
+| Change Type | Subsection |
+|---|---|
+| New feature | `### Features` |
+| Bug fix | `### Fixes` |
+| Refactoring, internal cleanup | `### Internal` |
+| Dependency update | `### Dependencies` |
+
+Create the subsection under `## Unreleased` if it does not already exist.
+
+### Entry format
+
+```markdown
+- <Short description of the change> ([#<PR_NUMBER>](https://github.com/getsentry/sentry-java/pull/<PR_NUMBER>))
+```
+
+Use the PR number returned by `sentry-skills:create-pr`. Match the style of existing entries — sentence case, ending with the PR link, no trailing period.
+
+### Commit and push
+
+Stage `CHANGELOG.md`, commit with message `changelog`, and push:
+
+```bash
+git add CHANGELOG.md
+git commit -m "changelog"
+git push
+```

From fc52bb86337ae3f36a8da009dac05c40ac7a1661 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Mon, 2 Mar 2026 12:27:45 +0100
Subject: [PATCH 018/391] docs: Add agent rules for API, options, and PR
 workflows (#5133)

* docs: Add agent rules for API, options, and PR workflows

Add cursor rules for public API surface (api.mdc), SDK options
(options.mdc), and PR workflow including stacked PRs (pr.mdc).
Update overview_dev.mdc to reference the new rules. Add Claude Code
skill for creating pull requests.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref: Remove create-java-pr skill from PR

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .cursor/rules/api.mdc          |  89 +++++++++++++
 .cursor/rules/options.mdc      | 115 ++++++++++++++++
 .cursor/rules/overview_dev.mdc |  23 ++++
 .cursor/rules/pr.mdc           | 231 +++++++++++++++++++++++++++++++++
 4 files changed, 458 insertions(+)
 create mode 100644 .cursor/rules/api.mdc
 create mode 100644 .cursor/rules/options.mdc
 create mode 100644 .cursor/rules/pr.mdc

diff --git a/.cursor/rules/api.mdc b/.cursor/rules/api.mdc
new file mode 100644
index 00000000000..c5a793d9240
--- /dev/null
+++ b/.cursor/rules/api.mdc
@@ -0,0 +1,89 @@
+---
+alwaysApply: false
+description: Public API surface, binary compatibility, and common classes to modify
+---
+# Java SDK Public API
+
+## API Compatibility
+
+Public API is tracked via `.api` files generated by the [Binary Compatibility Validator](https://github.com/Kotlin/binary-compatibility-validator) Gradle plugin. Each module has its own file at `<module>/api/<module>.api`.
+
+- **Never edit `.api` files manually.** Run `./gradlew apiDump` to regenerate them.
+- `./gradlew check` validates current code against `.api` files and fails on unintended changes.
+- `@ApiStatus.Internal` marks classes/methods as internal — they still appear in `.api` files but are not part of the public contract.
+- `@ApiStatus.Experimental` marks API that may change in future versions.
+
+## Key Public API Classes
+
+### Entry Point
+
+`Sentry` (`sentry` module) is the static entry point. Most public API methods on `Sentry` delegate to `getCurrentScopes()`. When adding a new method to `Sentry`, it typically calls through to `IScopes`.
+
+### Interfaces
+
+| Interface | Description |
+|-----------|-------------|
+| `IScope` | Single scope — holds data (tags, extras, breadcrumbs, attributes, user, contexts, etc.) |
+| `IScopes` | Multi-scope container — manages global, isolation, and current scope; delegates capture calls to `SentryClient` |
+| `ISpan` | Performance span — timing, tags, data, measurements |
+| `ITransaction` | Top-level transaction — extends `ISpan` |
+
+### Configuration
+
+`SentryOptions` is the base configuration class. Platform-specific subclasses:
+- `SentryAndroidOptions` — Android-specific options
+- Integration modules may add their own (e.g. `SentrySpringProperties`)
+
+New features must be **opt-in by default** — add a getter/setter pair to the appropriate options class.
+
+### Internal Classes (Not Public API)
+
+| Class | Description |
+|-------|-------------|
+| `SentryClient` | Sends events/envelopes to Sentry — receives captured data from `Scopes` |
+| `SentryEnvelope` / `SentryEnvelopeItem` | Low-level envelope serialization |
+| `Scope` | Concrete implementation of `IScope` |
+| `Scopes` | Concrete implementation of `IScopes` |
+
+## Adding New Public API
+
+When adding a new method that users can call (e.g. a new scope operation), these classes typically need changes:
+
+### Interfaces and Static API
+1. `IScope` — add the method signature
+2. `IScopes` — add the method signature (usually delegates to a scope)
+3. `Sentry` — add static method that calls `getCurrentScopes()`
+
+### Implementations
+4. `Scope` — actual implementation with data storage
+5. `Scopes` — delegates to the appropriate scope (global, isolation, or current based on `defaultScopeType`)
+6. `CombinedScopeView` — defines how the three scope types combine for reads (merge, first-wins, or specific scope)
+
+### No-Op and Adapter Classes
+7. `NoOpScope` — no-op stub for `IScope`
+8. `NoOpScopes` — no-op stub for `IScopes`
+9. `ScopesAdapter` — delegates to `Sentry` static API
+10. `HubAdapter` — deprecated bridge from old `IHub` API
+11. `HubScopesWrapper` — wraps `IScopes` as `IHub`
+
+### Serialization (if the data is sent to Sentry)
+12. Add serialization/deserialization in the relevant data class or create a new one implementing `JsonSerializable` and `JsonDeserializer`
+
+### Tests
+13. Write tests for all implementations, especially `Scope`, `Scopes`, `SentryTest`, and any new data classes
+14. No-op classes typically don't need separate tests unless they have non-trivial logic
+
+## Protocol / Data Model Classes
+
+Classes in the `io.sentry.protocol` package represent the Sentry event protocol. They implement `JsonSerializable` for serialization and have a companion `Deserializer` class implementing `JsonDeserializer`. When adding new fields to protocol classes, update both serialization and deserialization.
+
+## Namespaced APIs
+
+Newer features are namespaced under `Sentry.<feature>()` rather than added directly to `Sentry`. Each namespaced API has an interface, implementation, and no-op. Examples:
+
+- `Sentry.logger()` → `ILoggerApi` / `LoggerApi` / `NoOpLoggerApi` (structured logging, `io.sentry.logger` package)
+- `Sentry.metrics()` → `IMetricsApi` / `MetricsApi` / `NoOpMetricsApi` (metrics)
+
+Options for namespaced features are similarly nested under `SentryOptions`, e.g. `SentryOptions.getMetrics()`, `SentryOptions.getLogs()`.
+
+These APIs may share infrastructure like the type system (`SentryAttributeType.inferFrom()`) — changes to shared components (e.g. attribute types) may require updates across multiple namespaced APIs.
diff --git a/.cursor/rules/options.mdc b/.cursor/rules/options.mdc
new file mode 100644
index 00000000000..2d239da7813
--- /dev/null
+++ b/.cursor/rules/options.mdc
@@ -0,0 +1,115 @@
+---
+alwaysApply: false
+description: Adding and modifying SDK options
+---
+# Adding Options to the SDK
+
+New features must be **opt-in by default**. Options control whether a feature is enabled and how it behaves.
+
+## Namespaced Options
+
+Newer features use namespaced option classes nested inside `SentryOptions`, e.g.:
+- `SentryOptions.getLogs()` → `SentryOptions.Logs`
+- `SentryOptions.getMetrics()` → `SentryOptions.Metrics`
+
+Each namespaced options class is a `public static final class` inside `SentryOptions` with its own fields, getters/setters, and callbacks (e.g. `BeforeSendLogCallback`, `BeforeSendMetricCallback`).
+
+A typical namespaced options class contains:
+- `enabled` boolean (default `false` for opt-in)
+- `sampleRate` double (if the feature supports sampling)
+- `beforeSend` callback interface (nested inside the options class)
+
+To add a new namespaced options class:
+1. Create the `public static final class` inside `SentryOptions` with fields, getters/setters, and any callback interfaces
+2. Add a private field on `SentryOptions` initialized with `new SentryOptions.MyFeature()`
+3. Add getter/setter on `SentryOptions` annotated with `@ApiStatus.Experimental`
+
+## Direct (Non-Namespaced) Options
+
+Options that apply globally across the SDK (e.g. `dsn`, `environment`, `release`, `sampleRate`, `maxBreadcrumbs`) live as direct fields on `SentryOptions` with getter/setter pairs. Use this pattern for options that aren't tied to a specific feature namespace.
+
+## Configuration Layers
+
+Options can be set through multiple layers. When adding a new option, consider which layers apply:
+
+### 1. SentryOptions (always required)
+
+The core options class. Add the field (or nested class) with getter/setter here.
+
+**File:** `sentry/src/main/java/io/sentry/SentryOptions.java`
+
+**Tests:** `sentry/src/test/java/io/sentry/SentryOptionsTest.kt`
+- Test the default value
+- Test merge behavior (see layer 2)
+
+### 2. ExternalOptions (sentry.properties / environment variables)
+
+Allows setting options via `sentry.properties` file or system properties. Fields use nullable wrapper types (`@Nullable Boolean`, `@Nullable Double`) since unset means "don't override the default."
+
+**File:** `sentry/src/main/java/io/sentry/ExternalOptions.java`
+- Add `@Nullable` fields with getter/setter for each externally configurable option (e.g. `enableMetrics`, `logsSampleRate`)
+- Wire them in the static `from(PropertiesProvider)` method:
+  - Boolean: `propertiesProvider.getBooleanProperty("metrics.enabled")`
+  - Double: `propertiesProvider.getDoubleProperty("logs.sample-rate")`
+
+**File:** `sentry/src/main/java/io/sentry/SentryOptions.java` — `merge()` method
+- Add null-check blocks to apply each external option onto the namespaced options class:
+  ```java
+  if (options.isEnableMetrics() != null) {
+      getMetrics().setEnabled(options.isEnableMetrics());
+  }
+  if (options.getLogsSampleRate() != null) {
+      getLogs().setSampleRate(options.getLogsSampleRate());
+  }
+  ```
+
+**Tests:**
+- `sentry/src/test/java/io/sentry/ExternalOptionsTest.kt` — test true/false/null for booleans, valid values and null for doubles
+- `sentry/src/test/java/io/sentry/SentryOptionsTest.kt` — test merge applies values and test merge preserves defaults when unset
+
+### 3. Android Manifest Metadata (Android only)
+
+Allows setting options via `AndroidManifest.xml` `<meta-data>` tags.
+
+**File:** `sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java`
+- Add a `static final String` constant for the key (e.g. `"io.sentry.metrics.enabled"`)
+- Read it in `applyMetadata()` using `readBool(metadata, logger, CONSTANT, defaultValue)`
+- Apply to the namespaced options, e.g. `options.getMetrics().setEnabled(...)`
+
+**Tests:** `sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt`
+- Test default value preserved when not in manifest
+- Test explicit true
+- Test explicit false
+
+### 4. Spring Boot Properties (Spring Boot only)
+
+`SentryProperties` extends `SentryOptions`, so namespaced options (nested classes) are automatically available as Spring Boot properties without extra code. For example, `SentryOptions.Logs` is automatically mapped to `sentry.logs.enabled` in `application.properties`.
+
+No additional code is needed for namespaced options — Spring Boot auto-configuration handles this via property binding on the `SentryOptions` class hierarchy.
+
+**Tests:** `sentry-spring-boot*/src/test/kotlin/.../SentryAutoConfigurationTest.kt`
+- Add the property (e.g. `"sentry.logs.enabled=true"`) to the existing `resolves all properties` test
+- Assert the value is set on the resolved `SentryProperties` bean
+- There are three Spring Boot modules with separate test files: `sentry-spring-boot`, `sentry-spring-boot-jakarta`, `sentry-spring-boot-4`
+
+### 5. Reading Options at Runtime
+
+Features check their options at usage time. For namespaced features the check typically happens in the feature's API class (e.g. `LoggerApi`, `MetricsApi`):
+- Check `options.getLogs().isEnabled()` early and return if disabled
+- Apply sampling via `options.getLogs().getSampleRate()` if applicable
+- Apply `beforeSend` callback in `SentryClient` before sending
+
+When a feature has its own capture path (e.g. `captureLog`), the relevant classes are:
+- `ISentryClient` — add the capture method signature
+- `SentryClient` — implement capture, including `beforeSend` callback execution
+- `NoOpSentryClient` — add no-op stub
+
+## Checklist for Adding a New Namespaced Option
+
+1. `SentryOptions.java` — nested options class + getter/setter on `SentryOptions`
+2. `ExternalOptions.java` — `@Nullable` fields + wiring in `from()`
+3. `SentryOptions.java` `merge()` — apply external options to namespaced class
+4. `ManifestMetadataReader.java` — Android manifest support (if Android-relevant)
+5. `SentryAutoConfigurationTest.kt` — Spring Boot property binding tests (all three Spring Boot modules)
+6. Tests for all of the above (`SentryOptionsTest`, `ExternalOptionsTest`, `ManifestMetadataReaderTest`)
+7. Run `./gradlew apiDump` — the nested class and its methods appear in `sentry.api`
diff --git a/.cursor/rules/overview_dev.mdc b/.cursor/rules/overview_dev.mdc
index f05d2992d40..a982cfe960e 100644
--- a/.cursor/rules/overview_dev.mdc
+++ b/.cursor/rules/overview_dev.mdc
@@ -15,6 +15,19 @@ These rules are automatically included in every conversation:
 Use the `fetch_rules` tool to include these rules when working on specific areas:
 
 ### Core SDK Functionality
+- **`api`**: Use when working with:
+  - Adding or modifying public API surface
+  - Binary compatibility, `.api` files, `apiDump`
+  - Understanding which classes to modify for new API (interfaces, implementations, no-ops, adapters)
+  - `IScope`, `IScopes`, `Sentry` static API
+  - Attributes, logging API, protocol classes
+
+- **`options`**: Use when working with:
+  - Adding or modifying SDK options (`SentryOptions`, namespaced options)
+  - External options (`ExternalOptions`, `sentry.properties`, environment variables)
+  - Android manifest metadata (`ManifestMetadataReader`)
+  - Spring Boot properties (`SentryProperties`)
+
 - **`scopes`**: Use when working with:
   - Hub/Scope management, forking, or lifecycle
   - `Sentry.getCurrentScopes()`, `pushScope()`, `withScope()` 
@@ -63,6 +76,13 @@ Use the `fetch_rules` tool to include these rules when working on specific areas
 
 - **`new_module`**: Use when adding a new integration or sample module
 
+### Workflow
+- **`pr`**: Use when working with:
+  - Creating pull requests
+  - Stacked PRs, PR naming, stack comments
+  - PR changelog entries
+  - Merging or syncing stacked branches
+
 ### Testing
 - **`e2e_tests`**: Use when working with:
   - System tests, sample applications
@@ -76,6 +96,8 @@ Use the `fetch_rules` tool to include these rules when working on specific areas
 2. **Fetch on-demand**: Use `fetch_rules ["rule_name"]` when you identify specific domain work
 3. **Multiple rules**: Fetch multiple rules if task spans domains (e.g., `["scopes", "opentelemetry"]` for tracing scope issues)
 4. **Context clues**: Look for these keywords in requests to determine relevant rules:
+   - Public API/apiDump/.api files/binary compatibility/new method → `api`
+   - Options/SentryOptions/ExternalOptions/ManifestMetadataReader/sentry.properties → `options`
    - Scope/Hub/forking → `scopes`
    - Duplicate/dedup → `deduplication` 
    - OpenTelemetry/tracing/spans → `opentelemetry`
@@ -84,3 +106,4 @@ Use the `fetch_rules` tool to include these rules when working on specific areas
    - System test/e2e/sample → `e2e_tests`
    - Feature flag/addFeatureFlag/flag evaluation → `feature_flags`
    - Metrics/count/distribution/gauge → `metrics`
+   - PR/pull request/stacked PR/stack → `pr`
diff --git a/.cursor/rules/pr.mdc b/.cursor/rules/pr.mdc
new file mode 100644
index 00000000000..581c8cc95d5
--- /dev/null
+++ b/.cursor/rules/pr.mdc
@@ -0,0 +1,231 @@
+---
+alwaysApply: false
+description: Pull request creation, stacked PRs, and PR workflow
+---
+
+# Pull Request Rules
+
+## Creating a Pull Request
+
+### Step 1: Ensure Feature Branch
+
+If on `main`, create and switch to a new branch:
+
+```bash
+git checkout -b <type>/<short-description>
+```
+
+Branch names use `feat/`, `fix/`, `ref/`, etc. matching the commit type.
+
+### Step 2: Format Code and Regenerate API Files
+
+```bash
+./gradlew spotlessApply apiDump
+```
+
+This is **required** before every PR. Fix any failures before continuing.
+
+### Step 3: Commit Changes
+
+Use `git status --porcelain` to review changes. Ignore files only relevant for local testing (hardcoded debug toggles, sample app config, `.env` files). Restore those with `git checkout -- <file>`.
+
+Follow [Sentry commit message conventions](https://develop.sentry.dev/engineering-practices/commit-messages/):
+
+```
+<type>(<scope>): <subject>
+```
+
+Allowed types: `feat`, `fix`, `ref`, `chore`, `docs`, `test`, `perf`, `build`, `ci`, `style`, `meta`, `license`
+
+- Use imperative present tense ("add" not "added")
+- Capitalize subject, no trailing period
+- Keep under 100 characters
+
+### Step 4: Push
+
+```bash
+git push -u origin HEAD
+```
+
+If push fails due to diverged history, ask the user — do not force-push.
+
+### Step 5: Create PR
+
+Create a draft PR using the repo's PR template:
+
+```markdown
+## :scroll: Description
+<Describe the changes in detail>
+
+## :bulb: Motivation and Context
+<Why is this change required? What problem does it solve?>
+
+## :green_heart: How did you test it?
+<Describe how you tested>
+
+## :pencil: Checklist
+- [ ] I added GH Issue ID _&_ Linear ID
+- [ ] I added tests to verify the changes.
+- [ ] No new PII added or SDK only sends newly added PII if `sendDefaultPII` is enabled.
+- [ ] I updated the docs if needed.
+- [ ] I updated the wizard if needed.
+- [ ] Review from the native team if needed.
+- [ ] No breaking change or entry added to the changelog.
+- [ ] No breaking change for hybrid SDKs or communicated to hybrid SDKs.
+
+## :crystal_ball: Next steps
+```
+
+### Step 6: Update Changelog
+
+Add an entry to `CHANGELOG.md` under `## Unreleased` in the appropriate subsection:
+
+| Change Type | Subsection |
+|---|---|
+| New feature | `### Features` |
+| Bug fix | `### Fixes` |
+| Refactoring, internal cleanup | `### Internal` |
+| Dependency update | `### Dependencies` |
+
+Entry format:
+
+```markdown
+- <Short description> ([#<PR_NUMBER>](https://github.com/getsentry/sentry-java/pull/<PR_NUMBER>))
+```
+
+Commit changelog separately:
+
+```bash
+git add CHANGELOG.md && git commit -m "changelog" && git push
+```
+
+### PR Title Format
+
+Follow the commit message format:
+
+```
+<type>(<scope>): <Subject>
+```
+
+Examples:
+- `feat(core): Add structured logging support`
+- `fix(android): Prevent crash on API 21 when registering receiver`
+
+---
+
+## Stacked PRs
+
+Stacked PRs split a large feature into small, easy-to-review PRs where each builds on the previous one. This follows the same concept as the [Graphite](https://graphite.dev/) stacking workflow.
+
+### Structure
+
+```
+main → stack-pr-1 → stack-pr-2 → stack-pr-3 → ...
+```
+
+- The first PR in the stack targets `main` as its base branch.
+- Each subsequent PR targets the previous stack PR's branch as its base.
+- Each PR contains only incremental changes on top of the previous one.
+
+### Branch Naming
+
+Prefer a shared prefix for the feature, with descriptive suffixes per PR. The type prefix (`feat/`, `fix/`, etc.) may vary depending on the nature of each PR's changes:
+
+```
+feat/scope-attributes              # PR 1
+feat/scope-attributes-logger       # PR 2
+fix/attribute-type-detection        # PR 3 (fix, different name — that's fine)
+```
+
+### PR Title Naming
+
+Include the topic name and a sequential number in brackets:
+
+```
+<type>(<scope>): [<Topic> <N>] <Subject>
+```
+
+Examples:
+- `feat(core): [Global Attributes 1] Add scope-level attributes API`
+- `feat(core): [Global Attributes 2] Wire scope attributes into LoggerApi and MetricsApi`
+- `feat(samples): [Global Attributes 3] Showcase scope attributes in Spring Boot 4 sample`
+
+### Finding All PRs in a Stack
+
+Do **not** rely on branch name patterns — later PRs in a stack may use different prefixes or naming. Instead:
+
+1. Find the PR for the current branch:
+   ```bash
+   gh pr list --head "$(git branch --show-current)" --json number,title,baseRefName --jq '.[0]'
+   ```
+2. Read the stack comment on that PR — it lists every PR in the stack.
+3. If there is no stack comment yet, walk the chain in both directions:
+   ```bash
+   # Find the PR whose head branch is the current PR's base (go up)
+   gh pr list --head <baseRefName> --json number,title,baseRefName
+
+   # Find PRs whose base branch is the current PR's head (go down)
+   gh pr list --base <currentBranch> --json number,title,headRefName
+   ```
+   Repeat until you reach `main` going up and find no more PRs going down.
+
+### Creating a New Stacked PR
+
+1. Start from the tip of the previous stack branch (or `main` for the first PR).
+2. Create a new branch, make changes, format, commit, and push.
+3. Create the PR with `--base <previous-branch>`:
+   ```bash
+   gh pr create --base feat/previous-branch --draft --title "<type>(<scope>): [<Topic> <N>] <Subject>" --body "..."
+   ```
+4. Add the stack comment to the new PR and update it on all existing PRs in the stack (see below).
+
+### Stack Comment
+
+Every PR in the stack must have a comment listing all PRs in the stack. When a new PR is added, update the comment on **all** PRs in the stack.
+
+Format:
+
+```markdown
+## PR Stack (<Topic>)
+
+- [#5118](https://github.com/getsentry/sentry-java/pull/5118) — Add scope-level attributes API
+- [#5120](https://github.com/getsentry/sentry-java/pull/5120) — Wire scope attributes into LoggerApi and MetricsApi
+- [#5121](https://github.com/getsentry/sentry-java/pull/5121) — Showcase scope attributes in Spring Boot 4 samples
+```
+
+No status column — GitHub already shows that.
+
+To add or update the stack comment on a PR:
+
+```bash
+# Find existing stack comment (if any)
+gh api repos/getsentry/sentry-java/issues/<PR_NUMBER>/comments --jq '.[] | select(.body | startswith("## PR Stack")) | .id'
+
+# Create new comment
+gh pr comment <PR_NUMBER> --body "<stack comment body>"
+
+# Or update existing comment
+gh api repos/getsentry/sentry-java/issues/comments/<COMMENT_ID> -X PATCH -f body="<stack comment body>"
+```
+
+### Merging Stacked PRs
+
+Merge in order from bottom to top (PR 1 first, then PR 2, etc.). After each merge, the next PR's base automatically becomes the merged branch's target. GitHub handles rebasing onto the new base. Verify each PR's diff still looks correct after the previous one merges.
+
+### Syncing the Stack
+
+When a base PR changes (e.g. after addressing review feedback on PR 1), merge the changes forward through the stack:
+
+```bash
+# On the branch for PR 2
+git checkout feat/scope-attributes-logger
+git merge feat/scope-attributes
+git push
+
+# On the branch for PR 3
+git checkout feat/scope-attributes-sample
+git merge feat/scope-attributes-logger
+git push
+```
+
+Prefer merge over rebase — it preserves commit history, doesn't invalidate existing review comments, and avoids the need for force-pushing. Only rebase if explicitly requested.

From b7fde007e21f716653dd8f2f3ad9afd250899e89 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Mon, 2 Mar 2026 16:33:05 +0100
Subject: [PATCH 019/391] fix: Trim DSN string before URI parsing (#5113)

* fix: Trim DSN string before URI parsing

Trailing or leading whitespace in the DSN string (commonly introduced
by copy-paste) causes a URISyntaxException that crashes the application
on startup. Trim the DSN before passing it to the URI constructor.

Fixes GH-5087
Co-Authored-By: Claude <noreply@anthropic.com>

* docs: Add changelog entry for DSN trimming fix

Co-Authored-By: Claude <noreply@anthropic.com>

* also trim on SentryOptions.setDsn

* fix: Throw clear error when DSN is empty

Previously an empty or whitespace-only DSN string would fall through
to the URI constructor, producing a confusing error message. Now the
Dsn constructor checks for empty strings after trimming and throws
an IllegalArgumentException with a clear message.

Co-Authored-By: Claude <noreply@anthropic.com>

* Format code

* ci: retrigger checks

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                   |  1 +
 sentry/src/main/java/io/sentry/Dsn.java        |  7 +++++--
 .../src/main/java/io/sentry/SentryOptions.java |  2 +-
 sentry/src/test/java/io/sentry/DsnTest.kt      | 18 ++++++++++++++++++
 .../test/java/io/sentry/SentryOptionsTest.kt   | 18 ++++++++++++++++++
 5 files changed, 43 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dba0f4dcdfe..56a7be44b1b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -31,6 +31,7 @@
 ### Fixes
 
 - Fix crash when unregistering `SystemEventsBroadcastReceiver` with try-catch block. ([#5106](https://github.com/getsentry/sentry-java/pull/5106))
+- Trim DSN string before parsing to avoid `URISyntaxException` caused by trailing whitespace ([#5113](https://github.com/getsentry/sentry-java/pull/5113))
 
 ### Dependencies
 
diff --git a/sentry/src/main/java/io/sentry/Dsn.java b/sentry/src/main/java/io/sentry/Dsn.java
index 836e2c55468..705d383266e 100644
--- a/sentry/src/main/java/io/sentry/Dsn.java
+++ b/sentry/src/main/java/io/sentry/Dsn.java
@@ -50,8 +50,11 @@ URI getSentryUri() {
 
   Dsn(@Nullable String dsn) throws IllegalArgumentException {
     try {
-      Objects.requireNonNull(dsn, "The DSN is required.");
-      final URI uri = new URI(dsn).normalize();
+      final String dsnString = Objects.requireNonNull(dsn, "The DSN is required.").trim();
+      if (dsnString.isEmpty()) {
+        throw new IllegalArgumentException("The DSN is empty.");
+      }
+      final URI uri = new URI(dsnString).normalize();
       final String scheme = uri.getScheme();
       if (!("http".equalsIgnoreCase(scheme) || "https".equalsIgnoreCase(scheme))) {
         throw new IllegalArgumentException("Invalid DSN scheme: " + scheme);
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 14f4acf51fb..298e37795b3 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -749,7 +749,7 @@ Dsn retrieveParsedDsn() throws IllegalArgumentException {
    * @param dsn the DSN
    */
   public void setDsn(final @Nullable String dsn) {
-    this.dsn = dsn;
+    this.dsn = dsn != null ? dsn.trim() : null;
     this.parsedDsn.resetValue();
 
     dsnHash = StringUtils.calculateStringHash(this.dsn, logger);
diff --git a/sentry/src/test/java/io/sentry/DsnTest.kt b/sentry/src/test/java/io/sentry/DsnTest.kt
index eaa129c2073..6c454ad5c75 100644
--- a/sentry/src/test/java/io/sentry/DsnTest.kt
+++ b/sentry/src/test/java/io/sentry/DsnTest.kt
@@ -89,6 +89,24 @@ class DsnTest {
     assertEquals("http://host/api/id", dsn.sentryUri.toURL().toString())
   }
 
+  @Test
+  fun `dsn parsed with leading and trailing whitespace`() {
+    val dsn = Dsn("  https://key@host/id  ")
+    assertEquals("https://host/api/id", dsn.sentryUri.toURL().toString())
+  }
+
+  @Test
+  fun `when dsn is empty, throws exception`() {
+    val ex = assertFailsWith<IllegalArgumentException> { Dsn("") }
+    assertEquals("java.lang.IllegalArgumentException: The DSN is empty.", ex.message)
+  }
+
+  @Test
+  fun `when dsn is only whitespace, throws exception`() {
+    val ex = assertFailsWith<IllegalArgumentException> { Dsn("   ") }
+    assertEquals("java.lang.IllegalArgumentException: The DSN is empty.", ex.message)
+  }
+
   @Test
   fun `non http protocols are not accepted`() {
     assertFailsWith<IllegalArgumentException> { Dsn("ftp://publicKey:secretKey@host/path/id") }
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index 6868b55c2b9..80510db931f 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -588,6 +588,24 @@ class SentryOptionsTest {
     assertFalse(cacheDirPathWithoutDsn.contains(hash.toString()))
   }
 
+  @Test
+  fun `when setting dsn with whitespace, it is trimmed and produces the same cache dir path`() {
+    val dsn = "http://key@localhost/proj"
+    val options1 =
+      SentryOptions().apply {
+        setDsn(dsn)
+        cacheDirPath = "${File.separator}test"
+      }
+    val options2 =
+      SentryOptions().apply {
+        setDsn("  $dsn  ")
+        cacheDirPath = "${File.separator}test"
+      }
+
+    assertEquals(dsn, options2.dsn)
+    assertEquals(options1.cacheDirPath, options2.cacheDirPath)
+  }
+
   @Test
   fun `when options are initialized, idleTimeout is 3000`() {
     assertEquals(3000L, SentryOptions().idleTimeout)

From 9054d65b80c7a724faf4fefeaf104bba1f6e3f92 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Mon, 2 Mar 2026 17:26:44 +0100
Subject: [PATCH 020/391] fix(transport): Handle HTTP 413 with actionable log
 and use send_error for HTTP errors (#5115)

* fix(transport): Handle HTTP 413 with actionable log and use send_error for HTTP errors

Log a specific, actionable error message when Relay returns HTTP 413
(Content Too Large) instead of the generic "Request failed" message.
The message suggests reducing event/breadcrumb/attachment sizes and
mentions the `SentryOptions.onOversizedEvent` callback.

Also switch the client report discard reason for all HTTP 4xx/5xx
errors (except 429) from `network_error` to `send_error`, matching
the client reports spec and aligning with sentry-python and
sentry-cocoa.

Fixes GH-5050
Co-Authored-By: Claude <noreply@anthropic.com>

* docs: Add changelog entry for HTTP 413 handling

Co-Authored-By: Claude <noreply@anthropic.com>

* remove duplicate log message

* Update changelog for client report discard reason

Switch client report discard reason for HTTP 4xx/5xx errors.

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  2 +
 .../apache/ApacheHttpClientTransport.java     | 21 +++++--
 ...acheHttpClientTransportClientReportTest.kt | 32 +++++++++-
 sentry/api/sentry.api                         |  1 +
 .../io/sentry/clientreport/DiscardReason.java |  1 +
 .../sentry/transport/AsyncHttpTransport.java  |  2 +-
 .../io/sentry/transport/HttpConnection.java   | 13 +++-
 .../AsyncHttpTransportClientReportTest.kt     | 59 +++++++++++++++++--
 .../transport/AsyncHttpTransportTest.kt       | 25 ++++++++
 9 files changed, 144 insertions(+), 12 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 56a7be44b1b..fec0ecc646a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -31,6 +31,8 @@
 ### Fixes
 
 - Fix crash when unregistering `SystemEventsBroadcastReceiver` with try-catch block. ([#5106](https://github.com/getsentry/sentry-java/pull/5106))
+- Log an actionable error message when Relay returns HTTP 413 (Content Too Large) ([#5115](https://github.com/getsentry/sentry-java/pull/5115))
+  - Also switch the client report discard reason for all HTTP 4xx/5xx errors (except 429) from `network_error` to `send_error`
 - Trim DSN string before parsing to avoid `URISyntaxException` caused by trailing whitespace ([#5113](https://github.com/getsentry/sentry-java/pull/5113))
 
 ### Dependencies
diff --git a/sentry-apache-http-client-5/src/main/java/io/sentry/transport/apache/ApacheHttpClientTransport.java b/sentry-apache-http-client-5/src/main/java/io/sentry/transport/apache/ApacheHttpClientTransport.java
index 2cf1484b563..0d768bf1c52 100644
--- a/sentry-apache-http-client-5/src/main/java/io/sentry/transport/apache/ApacheHttpClientTransport.java
+++ b/sentry-apache-http-client-5/src/main/java/io/sentry/transport/apache/ApacheHttpClientTransport.java
@@ -113,16 +113,29 @@ public void send(final @NotNull SentryEnvelope envelope, final @NotNull Hint hin
                   @Override
                   public void completed(SimpleHttpResponse response) {
                     if (response.getCode() != 200) {
-                      options
-                          .getLogger()
-                          .log(ERROR, "Request failed, API returned %s", response.getCode());
+                      if (response.getCode() == 413) {
+                        options
+                            .getLogger()
+                            .log(
+                                ERROR,
+                                "Envelope was discarded by the server because it was too large."
+                                    + " Consider reducing the size of events, breadcrumbs,"
+                                    + " or attachments."
+                                    + " You can use the `SentryOptions.onOversizedEvent`"
+                                    + " callback to customize how oversized events"
+                                    + " are handled.");
+                      } else {
+                        options
+                            .getLogger()
+                            .log(ERROR, "Request failed, API returned %s", response.getCode());
+                      }
 
                       if (response.getCode() >= 400 && response.getCode() != 429) {
                         if (!HintUtils.hasType(hint, Retryable.class)) {
                           options
                               .getClientReportRecorder()
                               .recordLostEnvelope(
-                                  DiscardReason.NETWORK_ERROR, envelopeWithClientReport);
+                                  DiscardReason.SEND_ERROR, envelopeWithClientReport);
                         }
                       }
                     } else {
diff --git a/sentry-apache-http-client-5/src/test/kotlin/io/sentry/transport/apache/ApacheHttpClientTransportClientReportTest.kt b/sentry-apache-http-client-5/src/test/kotlin/io/sentry/transport/apache/ApacheHttpClientTransportClientReportTest.kt
index d110b802345..afe0b38538d 100644
--- a/sentry-apache-http-client-5/src/test/kotlin/io/sentry/transport/apache/ApacheHttpClientTransportClientReportTest.kt
+++ b/sentry-apache-http-client-5/src/test/kotlin/io/sentry/transport/apache/ApacheHttpClientTransportClientReportTest.kt
@@ -145,7 +145,7 @@ class ApacheHttpClientTransportClientReportTest {
       .attachReportToEnvelope(same(fixture.envelopeBeforeClientReportAttached))
     verify(fixture.clientReportRecorder, times(1))
       .recordLostEnvelope(
-        eq(DiscardReason.NETWORK_ERROR),
+        eq(DiscardReason.SEND_ERROR),
         same(fixture.envelopeAfterClientReportAttached),
       )
     verifyNoMoreInteractions(fixture.clientReportRecorder)
@@ -173,7 +173,7 @@ class ApacheHttpClientTransportClientReportTest {
       .attachReportToEnvelope(same(fixture.envelopeBeforeClientReportAttached))
     verify(fixture.clientReportRecorder, times(1))
       .recordLostEnvelope(
-        eq(DiscardReason.NETWORK_ERROR),
+        eq(DiscardReason.SEND_ERROR),
         same(fixture.envelopeAfterClientReportAttached),
       )
     verifyNoMoreInteractions(fixture.clientReportRecorder)
@@ -191,6 +191,34 @@ class ApacheHttpClientTransportClientReportTest {
     verifyNoMoreInteractions(fixture.clientReportRecorder)
   }
 
+  @Test
+  fun `records lost envelope with send_error on 413 for non retryable`() {
+    val sut = fixture.getSut(SimpleHttpResponse(413))
+
+    sut.send(fixture.envelopeBeforeClientReportAttached)
+
+    verify(fixture.clientReportRecorder, times(1))
+      .attachReportToEnvelope(same(fixture.envelopeBeforeClientReportAttached))
+    verify(fixture.clientReportRecorder, times(1))
+      .recordLostEnvelope(
+        eq(DiscardReason.SEND_ERROR),
+        same(fixture.envelopeAfterClientReportAttached),
+      )
+    verifyNoMoreInteractions(fixture.clientReportRecorder)
+  }
+
+  @Test
+  fun `does not record lost envelope on 413 error for retryable`() {
+    val sut = fixture.getSut(SimpleHttpResponse(413))
+
+    sut.send(fixture.envelopeBeforeClientReportAttached, retryableHint())
+
+    verify(fixture.clientReportRecorder, times(1))
+      .attachReportToEnvelope(same(fixture.envelopeBeforeClientReportAttached))
+    verify(fixture.clientReportRecorder, never()).recordLostEnvelope(any(), any())
+    verifyNoMoreInteractions(fixture.clientReportRecorder)
+  }
+
   @Test
   fun `does not record lost envelope on 429 error for non retryable`() {
     val sut = fixture.getSut(SimpleHttpResponse(429))
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 4399b191d21..c112e84608d 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -4806,6 +4806,7 @@ public final class io/sentry/clientreport/DiscardReason : java/lang/Enum {
 	public static final field QUEUE_OVERFLOW Lio/sentry/clientreport/DiscardReason;
 	public static final field RATELIMIT_BACKOFF Lio/sentry/clientreport/DiscardReason;
 	public static final field SAMPLE_RATE Lio/sentry/clientreport/DiscardReason;
+	public static final field SEND_ERROR Lio/sentry/clientreport/DiscardReason;
 	public fun getReason ()Ljava/lang/String;
 	public static fun valueOf (Ljava/lang/String;)Lio/sentry/clientreport/DiscardReason;
 	public static fun values ()[Lio/sentry/clientreport/DiscardReason;
diff --git a/sentry/src/main/java/io/sentry/clientreport/DiscardReason.java b/sentry/src/main/java/io/sentry/clientreport/DiscardReason.java
index 01031fbb3b7..98f25386a5f 100644
--- a/sentry/src/main/java/io/sentry/clientreport/DiscardReason.java
+++ b/sentry/src/main/java/io/sentry/clientreport/DiscardReason.java
@@ -5,6 +5,7 @@ public enum DiscardReason {
   CACHE_OVERFLOW("cache_overflow"),
   RATELIMIT_BACKOFF("ratelimit_backoff"),
   NETWORK_ERROR("network_error"),
+  SEND_ERROR("send_error"),
   SAMPLE_RATE("sample_rate"),
   BEFORE_SEND("before_send"),
   EVENT_PROCESSOR("event_processor"), // also for ignored exceptions
diff --git a/sentry/src/main/java/io/sentry/transport/AsyncHttpTransport.java b/sentry/src/main/java/io/sentry/transport/AsyncHttpTransport.java
index b664302f1e0..c4d54c173ef 100644
--- a/sentry/src/main/java/io/sentry/transport/AsyncHttpTransport.java
+++ b/sentry/src/main/java/io/sentry/transport/AsyncHttpTransport.java
@@ -315,7 +315,7 @@ public void run() {
               if (result.getResponseCode() != 429) {
                 options
                     .getClientReportRecorder()
-                    .recordLostEnvelope(DiscardReason.NETWORK_ERROR, envelopeWithClientReport);
+                    .recordLostEnvelope(DiscardReason.SEND_ERROR, envelopeWithClientReport);
               }
             }
 
diff --git a/sentry/src/main/java/io/sentry/transport/HttpConnection.java b/sentry/src/main/java/io/sentry/transport/HttpConnection.java
index 3256804201a..71c3ebb15b2 100644
--- a/sentry/src/main/java/io/sentry/transport/HttpConnection.java
+++ b/sentry/src/main/java/io/sentry/transport/HttpConnection.java
@@ -180,7 +180,18 @@ HttpURLConnection open() throws IOException {
       updateRetryAfterLimits(connection, responseCode);
 
       if (!isSuccessfulResponseCode(responseCode)) {
-        options.getLogger().log(ERROR, "Request failed, API returned %s", responseCode);
+        if (responseCode == 413) {
+          options
+              .getLogger()
+              .log(
+                  ERROR,
+                  "Envelope was discarded by the server because it was too large."
+                      + " Consider reducing the size of events, breadcrumbs, or attachments."
+                      + " You can use the `SentryOptions.onOversizedEvent` callback"
+                      + " to customize how oversized events are handled.");
+        } else {
+          options.getLogger().log(ERROR, "Request failed, API returned %s", responseCode);
+        }
         // double check because call is expensive
         if (options.isDebug()) {
           final @NotNull String errorMessage = getErrorMessageFromStream(connection);
diff --git a/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportClientReportTest.kt b/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportClientReportTest.kt
index ec05af3df36..6877d521d26 100644
--- a/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportClientReportTest.kt
+++ b/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportClientReportTest.kt
@@ -94,7 +94,7 @@ class AsyncHttpTransportClientReportTest {
       .attachReportToEnvelope(same(fixture.envelopeBeforeAttachingClientReport))
     verify(fixture.clientReportRecorder, times(1))
       .recordLostEnvelope(
-        eq(DiscardReason.NETWORK_ERROR),
+        eq(DiscardReason.SEND_ERROR),
         same(fixture.envelopeAfterAttachingClientReport),
       )
     verifyNoMoreInteractions(fixture.clientReportRecorder)
@@ -118,7 +118,7 @@ class AsyncHttpTransportClientReportTest {
       .attachReportToEnvelope(same(fixture.envelopeBeforeAttachingClientReport))
     verify(fixture.clientReportRecorder, times(1))
       .recordLostEnvelope(
-        eq(DiscardReason.NETWORK_ERROR),
+        eq(DiscardReason.SEND_ERROR),
         same(fixture.envelopeAfterAttachingClientReport),
       )
     verifyNoMoreInteractions(fixture.clientReportRecorder)
@@ -145,7 +145,7 @@ class AsyncHttpTransportClientReportTest {
       .attachReportToEnvelope(same(fixture.envelopeBeforeAttachingClientReport))
     verify(fixture.clientReportRecorder, times(1))
       .recordLostEnvelope(
-        eq(DiscardReason.NETWORK_ERROR),
+        eq(DiscardReason.SEND_ERROR),
         same(fixture.envelopeAfterAttachingClientReport),
       )
     verifyNoMoreInteractions(fixture.clientReportRecorder)
@@ -169,12 +169,63 @@ class AsyncHttpTransportClientReportTest {
       .attachReportToEnvelope(same(fixture.envelopeBeforeAttachingClientReport))
     verify(fixture.clientReportRecorder, times(1))
       .recordLostEnvelope(
-        eq(DiscardReason.NETWORK_ERROR),
+        eq(DiscardReason.SEND_ERROR),
         same(fixture.envelopeAfterAttachingClientReport),
       )
     verifyNoMoreInteractions(fixture.clientReportRecorder)
   }
 
+  @Test
+  fun `records lost envelope with send_error on 413 for retryable`() {
+    // given
+    givenSetup(TransportResult.error(413))
+    whenever(
+        fixture.envelopeCache.storeEnvelope(eq(fixture.envelopeBeforeAttachingClientReport), any())
+      )
+      .thenReturn(true)
+
+    // when
+    val retryableHint = retryableHint()
+    assertFailsWith(java.lang.IllegalStateException::class) {
+      fixture.getSUT().send(fixture.envelopeBeforeAttachingClientReport, retryableHint)
+    }
+
+    // then
+    verify(fixture.clientReportRecorder, times(1))
+      .attachReportToEnvelope(same(fixture.envelopeBeforeAttachingClientReport))
+    verify(fixture.clientReportRecorder, times(1))
+      .recordLostEnvelope(
+        eq(DiscardReason.SEND_ERROR),
+        same(fixture.envelopeAfterAttachingClientReport),
+      )
+    verifyNoMoreInteractions(fixture.clientReportRecorder)
+    val sentrySdkHint = HintUtils.getSentrySdkHint(retryableHint)
+    assertFalse((sentrySdkHint as Retryable).isRetry)
+    verify(fixture.envelopeCache).discard(fixture.envelopeBeforeAttachingClientReport)
+  }
+
+  @Test
+  fun `records lost envelope with send_error on 413 for non retryable`() {
+    // given
+    givenSetup(TransportResult.error(413))
+
+    // when
+    assertFailsWith(java.lang.IllegalStateException::class) {
+      fixture.getSUT().send(fixture.envelopeBeforeAttachingClientReport)
+    }
+
+    // then
+    verify(fixture.clientReportRecorder, times(1))
+      .attachReportToEnvelope(same(fixture.envelopeBeforeAttachingClientReport))
+    verify(fixture.clientReportRecorder, times(1))
+      .recordLostEnvelope(
+        eq(DiscardReason.SEND_ERROR),
+        same(fixture.envelopeAfterAttachingClientReport),
+      )
+    verifyNoMoreInteractions(fixture.clientReportRecorder)
+    verify(fixture.envelopeCache).discard(fixture.envelopeBeforeAttachingClientReport)
+  }
+
   @Test
   fun `records lost envelope on full queue for non retryable`() {
     // given
diff --git a/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportTest.kt b/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportTest.kt
index 90bd05069ef..70092ffa7ba 100644
--- a/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportTest.kt
+++ b/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportTest.kt
@@ -156,6 +156,31 @@ class AsyncHttpTransportTest {
     order.verify(fixture.sentryOptions.envelopeDiskCache).discard(eq(envelope))
   }
 
+  @Test
+  fun `discards envelope after unsuccessful send 413`() {
+    // given
+    val envelope = SentryEnvelope.from(fixture.sentryOptions.serializer, createSession(), null)
+    whenever(fixture.transportGate.isConnected).thenReturn(true)
+    whenever(fixture.rateLimiter.filter(eq(envelope), anyOrNull())).thenReturn(envelope)
+    whenever(fixture.connection.send(any())).thenReturn(TransportResult.error(413))
+
+    // when
+    try {
+      fixture.getSUT().send(envelope)
+    } catch (e: IllegalStateException) {
+      // expected - this is how the AsyncConnection signals failure to the executor for it to retry
+    }
+
+    // then
+    val order = inOrder(fixture.connection, fixture.sentryOptions.envelopeDiskCache)
+
+    // because storeBeforeSend is enabled by default
+    order.verify(fixture.sentryOptions.envelopeDiskCache).storeEnvelope(eq(envelope), anyOrNull())
+
+    order.verify(fixture.connection).send(eq(envelope))
+    order.verify(fixture.sentryOptions.envelopeDiskCache).discard(eq(envelope))
+  }
+
   @Test
   fun `discards envelope after unsuccessful send 429`() {
     // given

From 5a20352b4a4493259a3a889424e915d614655871 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Tue, 3 Mar 2026 10:17:18 +0100
Subject: [PATCH 021/391] fix(init): Reduce allocations and bytecode
 instructions during Sentry.init (#5135)

* fix(init): Perform less allocation/bytecode instructions in Sentry.init

* Switch new thread to executorService in AssetsModulesLoader

* activate options earlier

* changelog

* fix: Prevent SpotlightIntegration from being re-added after user removal

Use AtomicBoolean to ensure activate() only loads SpotlightIntegration
once, so users can remove it in their configuration callback without
it being re-added by the second activate() call from Sentry.init().

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../core/AndroidOptionsInitializer.java       |  3 +-
 .../internal/modules/AssetsModulesLoader.java | 18 ++++++++----
 .../sentry/android/core/SentryAndroidTest.kt  | 14 +++++++++
 .../modules/AssetsModulesLoaderTest.kt        |  7 +++--
 ...DuplicateEventDetectionEventProcessor.java |  3 +-
 .../java/io/sentry/MainEventProcessor.java    | 14 +--------
 .../io/sentry/SentryExceptionFactory.java     |  4 +--
 .../main/java/io/sentry/SentryOptions.java    | 29 ++++++++++++-------
 .../java/io/sentry/SentryThreadFactory.java   |  4 +--
 .../UncaughtExceptionHandlerIntegration.java  |  2 +-
 11 files changed, 58 insertions(+), 41 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fec0ecc646a..e50e09b72b7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -34,6 +34,7 @@
 - Log an actionable error message when Relay returns HTTP 413 (Content Too Large) ([#5115](https://github.com/getsentry/sentry-java/pull/5115))
   - Also switch the client report discard reason for all HTTP 4xx/5xx errors (except 429) from `network_error` to `send_error`
 - Trim DSN string before parsing to avoid `URISyntaxException` caused by trailing whitespace ([#5113](https://github.com/getsentry/sentry-java/pull/5113))
+- Reduce allocations and bytecode instructions during `Sentry.init` ([#5135](https://github.com/getsentry/sentry-java/pull/5135))
 
 ### Dependencies
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 5bfebaed922..589c4f8d2a1 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -142,6 +142,7 @@ static void loadDefaultAndMetadataOptions(
 
     readDefaultOptionValues(options, finalContext, buildInfoProvider);
     AppState.getInstance().registerLifecycleObserver(options);
+    options.activate();
   }
 
   @TestOnly
@@ -200,7 +201,7 @@ static void initializeIntegrationsAndProcessors(
     final @NotNull AppStartMetrics appStartMetrics = AppStartMetrics.getInstance();
 
     if (options.getModulesLoader() instanceof NoOpModulesLoader) {
-      options.setModulesLoader(new AssetsModulesLoader(context, options.getLogger()));
+      options.setModulesLoader(new AssetsModulesLoader(context, options));
     }
     if (options.getDebugMetaLoader() instanceof NoOpDebugMetaLoader) {
       options.setDebugMetaLoader(new AssetsDebugMetaLoader(context, options.getLogger()));
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/modules/AssetsModulesLoader.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/modules/AssetsModulesLoader.java
index 05bb75a60f4..1aa8a89f8fc 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/modules/AssetsModulesLoader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/modules/AssetsModulesLoader.java
@@ -1,8 +1,8 @@
 package io.sentry.android.core.internal.modules;
 
 import android.content.Context;
-import io.sentry.ILogger;
 import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
 import io.sentry.android.core.ContextUtils;
 import io.sentry.internal.modules.ModulesLoader;
 import java.io.FileNotFoundException;
@@ -18,13 +18,21 @@ public final class AssetsModulesLoader extends ModulesLoader {
 
   private final @NotNull Context context;
 
-  public AssetsModulesLoader(final @NotNull Context context, final @NotNull ILogger logger) {
-    super(logger);
+  public AssetsModulesLoader(final @NotNull Context context, final @NotNull SentryOptions options) {
+    super(options.getLogger());
     this.context = ContextUtils.getApplicationContext(context);
 
     // pre-load modules on a bg thread to avoid doing so on the main thread in case of a crash/error
-    //noinspection Convert2MethodRef
-    new Thread(() -> getOrLoadModules()).start();
+    try {
+      options
+          .getExecutorService()
+          .submit(
+              () -> {
+                getOrLoadModules();
+              });
+    } catch (Throwable e) {
+      options.getLogger().log(SentryLevel.ERROR, "AssetsModulesLoader submit failed", e);
+    }
   }
 
   @Override
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
index 716d03d8d7a..b7fad8abee2 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
@@ -16,6 +16,7 @@ import io.sentry.DateUtils
 import io.sentry.Hint
 import io.sentry.ILogger
 import io.sentry.ISentryClient
+import io.sentry.NoOpSentryExecutorService
 import io.sentry.Sentry
 import io.sentry.Sentry.OptionsConfiguration
 import io.sentry.SentryEnvelope
@@ -528,6 +529,19 @@ class SentryAndroidTest {
     assertEquals(99, AppStartMetrics.getInstance().appStartTimeSpan.startUptimeMs)
   }
 
+  @Test
+  fun `executor service is not NoOp when AndroidConnectionStatusProvider is initialized`() {
+    var executorServiceIsNoOp = true
+    fixture.initSut(context = context) { options ->
+      options.dsn = "https://key@sentry.io/123"
+      // the config callback runs before initializeIntegrationsAndProcessors, which creates
+      // AndroidConnectionStatusProvider - so if the executor is already real here,
+      // it's guaranteed to be real when the provider calls submitSafe()
+      executorServiceIsNoOp = options.executorService is NoOpSentryExecutorService
+    }
+    assertFalse(executorServiceIsNoOp)
+  }
+
   @Test
   fun `if the config options block throws still intializes android event processors`() {
     lateinit var optionsRef: SentryOptions
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/modules/AssetsModulesLoaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/modules/AssetsModulesLoaderTest.kt
index 9df02a067d0..128087a315d 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/modules/AssetsModulesLoaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/modules/AssetsModulesLoaderTest.kt
@@ -2,7 +2,8 @@ package io.sentry.android.core.internal.modules
 
 import android.content.Context
 import android.content.res.AssetManager
-import io.sentry.ILogger
+import io.sentry.SentryOptions
+import io.sentry.test.ImmediateExecutorService
 import java.io.FileNotFoundException
 import java.nio.charset.Charset
 import kotlin.test.Test
@@ -16,7 +17,7 @@ class AssetsModulesLoaderTest {
   class Fixture {
     val context = mock<Context>()
     val assets = mock<AssetManager>()
-    val logger = mock<ILogger>()
+    val options = SentryOptions().apply { executorService = ImmediateExecutorService() }
 
     fun getSut(
       fileName: String = "sentry-external-modules.txt",
@@ -31,7 +32,7 @@ class AssetsModulesLoaderTest {
         whenever(assets.open(fileName)).thenThrow(FileNotFoundException())
       }
       whenever(context.assets).thenReturn(assets)
-      return AssetsModulesLoader(context, logger)
+      return AssetsModulesLoader(context, options)
     }
   }
 
diff --git a/sentry/src/main/java/io/sentry/DuplicateEventDetectionEventProcessor.java b/sentry/src/main/java/io/sentry/DuplicateEventDetectionEventProcessor.java
index 5004e6514e9..fc178d789f3 100644
--- a/sentry/src/main/java/io/sentry/DuplicateEventDetectionEventProcessor.java
+++ b/sentry/src/main/java/io/sentry/DuplicateEventDetectionEventProcessor.java
@@ -1,6 +1,5 @@
 package io.sentry;
 
-import io.sentry.util.Objects;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -16,7 +15,7 @@ public final class DuplicateEventDetectionEventProcessor implements EventProcess
   private final @NotNull SentryOptions options;
 
   public DuplicateEventDetectionEventProcessor(final @NotNull SentryOptions options) {
-    this.options = Objects.requireNonNull(options, "options are required");
+    this.options = options;
   }
 
   @Override
diff --git a/sentry/src/main/java/io/sentry/MainEventProcessor.java b/sentry/src/main/java/io/sentry/MainEventProcessor.java
index 5ad19c79e32..8c684bfb65a 100644
--- a/sentry/src/main/java/io/sentry/MainEventProcessor.java
+++ b/sentry/src/main/java/io/sentry/MainEventProcessor.java
@@ -8,7 +8,6 @@
 import io.sentry.protocol.SentryTransaction;
 import io.sentry.protocol.User;
 import io.sentry.util.HintUtils;
-import io.sentry.util.Objects;
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -29,7 +28,7 @@ public final class MainEventProcessor implements EventProcessor, Closeable {
   private volatile @Nullable HostnameCache hostnameCache = null;
 
   public MainEventProcessor(final @NotNull SentryOptions options) {
-    this.options = Objects.requireNonNull(options, "The SentryOptions is required.");
+    this.options = options;
 
     final SentryStackTraceFactory sentryStackTraceFactory =
         new SentryStackTraceFactory(this.options);
@@ -38,17 +37,6 @@ public MainEventProcessor(final @NotNull SentryOptions options) {
     sentryThreadFactory = new SentryThreadFactory(sentryStackTraceFactory);
   }
 
-  MainEventProcessor(
-      final @NotNull SentryOptions options,
-      final @NotNull SentryThreadFactory sentryThreadFactory,
-      final @NotNull SentryExceptionFactory sentryExceptionFactory) {
-    this.options = Objects.requireNonNull(options, "The SentryOptions is required.");
-    this.sentryThreadFactory =
-        Objects.requireNonNull(sentryThreadFactory, "The SentryThreadFactory is required.");
-    this.sentryExceptionFactory =
-        Objects.requireNonNull(sentryExceptionFactory, "The SentryExceptionFactory is required.");
-  }
-
   @Override
   public @NotNull SentryEvent process(final @NotNull SentryEvent event, final @NotNull Hint hint) {
     setCommons(event);
diff --git a/sentry/src/main/java/io/sentry/SentryExceptionFactory.java b/sentry/src/main/java/io/sentry/SentryExceptionFactory.java
index 8b2b5709463..d47776a1627 100644
--- a/sentry/src/main/java/io/sentry/SentryExceptionFactory.java
+++ b/sentry/src/main/java/io/sentry/SentryExceptionFactory.java
@@ -6,7 +6,6 @@
 import io.sentry.protocol.SentryStackFrame;
 import io.sentry.protocol.SentryStackTrace;
 import io.sentry.protocol.SentryThread;
-import io.sentry.util.Objects;
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Deque;
@@ -31,8 +30,7 @@ public final class SentryExceptionFactory {
    * @param sentryStackTraceFactory the sentryStackTraceFactory
    */
   public SentryExceptionFactory(final @NotNull SentryStackTraceFactory sentryStackTraceFactory) {
-    this.sentryStackTraceFactory =
-        Objects.requireNonNull(sentryStackTraceFactory, "The SentryStackTraceFactory is required.");
+    this.sentryStackTraceFactory = sentryStackTraceFactory;
   }
 
   @NotNull
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 298e37795b3..7b21661c223 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -46,6 +46,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.atomic.AtomicBoolean;
 import javax.net.ssl.SSLSocketFactory;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
@@ -318,6 +319,12 @@ public class SentryOptions {
   /** Sentry Executor Service that sends cached events and envelopes on App. start. */
   private @NotNull ISentryExecutorService executorService = NoOpSentryExecutorService.getInstance();
 
+  /**
+   * Whether SpotlightIntegration has already been loaded via reflection. This prevents re-adding it
+   * if the user removed it in their configuration callback and activate() is called again.
+   */
+  private final @NotNull AtomicBoolean spotlightIntegrationLoaded = new AtomicBoolean(false);
+
   /** connection timeout in milliseconds. */
   private int connectionTimeoutMillis = 30_000;
 
@@ -655,6 +662,18 @@ public void activate() {
       executorService = new SentryExecutorService(this);
       executorService.prewarm();
     }
+
+    // SpotlightIntegration is loaded via reflection to allow the sentry-spotlight module
+    // to be excluded from release builds, preventing insecure HTTP URLs from appearing in APKs.
+    // Only attempt once to avoid re-adding after user removal in their configuration callback.
+    if (spotlightIntegrationLoaded.compareAndSet(false, true)) {
+      try {
+        final Class<?> clazz = Class.forName("io.sentry.spotlight.SpotlightIntegration");
+        integrations.add((Integration) clazz.getConstructor().newInstance());
+      } catch (Throwable ignored) {
+        // SpotlightIntegration not available
+      }
+    }
   }
 
   /**
@@ -3340,16 +3359,6 @@ private SentryOptions(final boolean empty) {
 
       integrations.add(new ShutdownHookIntegration());
 
-      // SpotlightIntegration is loaded via reflection to allow the sentry-spotlight module
-      // to be excluded from release builds, preventing insecure HTTP URLs from appearing in APKs
-      try {
-        final Class<?> clazz = Class.forName("io.sentry.spotlight.SpotlightIntegration");
-        final Integration spotlight = (Integration) clazz.getConstructor().newInstance();
-        integrations.add(spotlight);
-      } catch (Throwable ignored) {
-        // SpotlightIntegration not available
-      }
-
       eventProcessors.add(new MainEventProcessor(this));
       eventProcessors.add(new DuplicateEventDetectionEventProcessor(this));
 
diff --git a/sentry/src/main/java/io/sentry/SentryThreadFactory.java b/sentry/src/main/java/io/sentry/SentryThreadFactory.java
index 0b8f2584996..8bd14483269 100644
--- a/sentry/src/main/java/io/sentry/SentryThreadFactory.java
+++ b/sentry/src/main/java/io/sentry/SentryThreadFactory.java
@@ -3,7 +3,6 @@
 import io.sentry.protocol.SentryStackFrame;
 import io.sentry.protocol.SentryStackTrace;
 import io.sentry.protocol.SentryThread;
-import io.sentry.util.Objects;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -26,8 +25,7 @@ public final class SentryThreadFactory {
    * @param sentryStackTraceFactory the SentryStackTraceFactory
    */
   public SentryThreadFactory(final @NotNull SentryStackTraceFactory sentryStackTraceFactory) {
-    this.sentryStackTraceFactory =
-        Objects.requireNonNull(sentryStackTraceFactory, "The SentryStackTraceFactory is required.");
+    this.sentryStackTraceFactory = sentryStackTraceFactory;
   }
 
   /**
diff --git a/sentry/src/main/java/io/sentry/UncaughtExceptionHandlerIntegration.java b/sentry/src/main/java/io/sentry/UncaughtExceptionHandlerIntegration.java
index 8ca02cb8550..6ea61895799 100644
--- a/sentry/src/main/java/io/sentry/UncaughtExceptionHandlerIntegration.java
+++ b/sentry/src/main/java/io/sentry/UncaughtExceptionHandlerIntegration.java
@@ -44,7 +44,7 @@ public UncaughtExceptionHandlerIntegration() {
   }
 
   UncaughtExceptionHandlerIntegration(final @NotNull UncaughtExceptionHandler threadAdapter) {
-    this.threadAdapter = Objects.requireNonNull(threadAdapter, "threadAdapter is required.");
+    this.threadAdapter = threadAdapter;
   }
 
   @Override

From bcd5eb7c3afca745431c5ab8b4452d66edfbb6c7 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 3 Mar 2026 10:24:27 +0100
Subject: [PATCH 022/391] fix(test): Fix flaky previous session finalization
 test (#5139)

Use awaitility to wait for the previous session file to be deleted
instead of asserting immediately. The PreviousSessionFinalizer runs
as a separate task after the test's task in the single-threaded
executor, so there is a race between the assertion and the file
deletion.

Co-authored-by: Claude <noreply@anthropic.com>
---
 sentry/src/test/java/io/sentry/SentryTest.kt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/sentry/src/test/java/io/sentry/SentryTest.kt b/sentry/src/test/java/io/sentry/SentryTest.kt
index 72febe35665..c3da8c1c123 100644
--- a/sentry/src/test/java/io/sentry/SentryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTest.kt
@@ -964,7 +964,9 @@ class SentryTest {
     }
 
     await.untilTrue(triggered)
-    assertFalse(previousSessionFile.exists())
+    // The PreviousSessionFinalizer runs as a separate task after the test's task in the
+    // single-threaded executor, so we need to wait for it to delete the file too.
+    await.until { !previousSessionFile.exists() }
   }
 
   @Test

From 7b67c20caa4817c8f6da4a85cac35af3e159cb19 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 3 Mar 2026 10:25:31 +0100
Subject: [PATCH 023/391] fix(test): Fix flaky background-foreground replay
 test (#5140)

Increase sessionIntervalMillis from 2ms to 500ms so the timer task
from the first onBackground() doesn't fire before cancelTask() in
the second onForeground() can cancel it. With 2ms the timer could
race and call replayController.stop() twice.

Co-authored-by: Claude <noreply@anthropic.com>
---
 .../test/java/io/sentry/android/core/LifecycleWatcherTest.kt   | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt
index 5149f167129..09c4fae8dc4 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt
@@ -282,7 +282,8 @@ class LifecycleWatcherTest {
   @Test
   fun `background-foreground replay`() {
     whenever(fixture.dateProvider.currentTimeMillis).thenReturn(1L)
-    val watcher = fixture.getSUT(sessionIntervalMillis = 2L, enableAppLifecycleBreadcrumbs = false)
+    val watcher =
+      fixture.getSUT(sessionIntervalMillis = 500L, enableAppLifecycleBreadcrumbs = false)
     watcher.onForeground()
     verify(fixture.replayController).start()
 

From 56d97d56e07972fc1d9ee3f3c756f0891f0de64a Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Tue, 3 Mar 2026 10:36:03 +0100
Subject: [PATCH 024/391] fix(android): Remove AndroidRuntimeManager to prevent
 ANRs during SDK init (#5127)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(android): Remove AndroidRuntimeManager to prevent ANRs during SDK init

StrictMode.setVmPolicy()/setThreadPolicy() calls inside
runWithRelaxedPolicy() triggered binder IPC on the main thread, causing
ANRs (SDK-CRASHES-JAVA-32FQ 34k+, SDK-CRASHES-JAVA-32PH 21k+,
SDK-CRASHES-JAVA-32Q9 18k+ events). StrictMode only logs warnings in
production by default, so relaxing it is unnecessary and harmful.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog: Add entry for AndroidRuntimeManager removal

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(test): Remove initNotThrowStrictMode test

This test validated that StrictMode with penaltyDeath() didn't crash
during SDK init. Since we removed the RuntimeManager that relaxed
StrictMode, this test is no longer applicable — the SDK no longer
attempts to suppress StrictMode violations.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   1 +
 .../core/AndroidOptionsInitializer.java       |  10 +-
 .../ApplicationExitInfoEventProcessor.java    |   2 +-
 .../core/DefaultAndroidEventProcessor.java    |   4 +-
 .../sentry/android/core/DeviceInfoUtil.java   |  38 +++--
 .../android/core/InternalSentrySdk.java       |   3 +-
 .../core/SentryPerformanceProvider.java       |   6 +-
 .../core/cache/AndroidEnvelopeCache.java      |   5 +-
 .../internal/util/AndroidRuntimeManager.java  |  32 -----
 .../core/AndroidOptionsInitializerTest.kt     |   7 -
 .../util/AndroidRuntimeManagerTest.kt         | 130 ------------------
 .../io/sentry/uitest/android/SdkInitTests.kt  |  50 -------
 sentry/api/sentry.api                         |  17 ---
 sentry/src/main/java/io/sentry/Sentry.java    |   6 +-
 .../main/java/io/sentry/SentryOptions.java    |  25 ----
 .../sentry/util/runtime/IRuntimeManager.java  |  15 --
 .../util/runtime/NeutralRuntimeManager.java   |  17 ---
 .../util/runtime/NeutralRuntimeManagerTest.kt |  61 --------
 18 files changed, 29 insertions(+), 400 deletions(-)
 delete mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/internal/util/AndroidRuntimeManager.java
 delete mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/internal/util/AndroidRuntimeManagerTest.kt
 delete mode 100644 sentry/src/main/java/io/sentry/util/runtime/IRuntimeManager.java
 delete mode 100644 sentry/src/main/java/io/sentry/util/runtime/NeutralRuntimeManager.java
 delete mode 100644 sentry/src/test/java/io/sentry/util/runtime/NeutralRuntimeManagerTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e50e09b72b7..35aa59686f4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,7 @@
 
 ### Fixes
 
+- Remove `AndroidRuntimeManager` StrictMode relaxation to prevent ANRs during SDK init ([#5127](https://github.com/getsentry/sentry-java/pull/5127))
 - Fix crash when unregistering `SystemEventsBroadcastReceiver` with try-catch block. ([#5106](https://github.com/getsentry/sentry-java/pull/5106))
 - Log an actionable error message when Relay returns HTTP 413 (Content Too Large) ([#5115](https://github.com/getsentry/sentry-java/pull/5115))
   - Also switch the client report discard reason for all HTTP 4xx/5xx errors (except 429) from `network_error` to `send_error`
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 589c4f8d2a1..a189b30d07b 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -32,7 +32,6 @@
 import io.sentry.android.core.internal.modules.AssetsModulesLoader;
 import io.sentry.android.core.internal.util.AndroidConnectionStatusProvider;
 import io.sentry.android.core.internal.util.AndroidCurrentDateProvider;
-import io.sentry.android.core.internal.util.AndroidRuntimeManager;
 import io.sentry.android.core.internal.util.AndroidThreadChecker;
 import io.sentry.android.core.internal.util.SentryFrameMetricsCollector;
 import io.sentry.android.core.performance.AppStartMetrics;
@@ -123,7 +122,6 @@ static void loadDefaultAndMetadataOptions(
     options.setDefaultScopeType(ScopeType.CURRENT);
     options.setOpenTelemetryMode(SentryOpenTelemetryMode.OFF);
     options.setDateProvider(new SentryAndroidDateProvider());
-    options.setRuntimeManager(new AndroidRuntimeManager());
     options.getLogs().setLoggerBatchProcessorFactory(new AndroidLoggerBatchProcessorFactory());
     options.getMetrics().setMetricsBatchProcessorFactory(new AndroidMetricsBatchProcessorFactory());
 
@@ -135,10 +133,7 @@ static void loadDefaultAndMetadataOptions(
 
     ManifestMetadataReader.applyMetadata(finalContext, options, buildInfoProvider);
 
-    options.setCacheDirPath(
-        options
-            .getRuntimeManager()
-            .runWithRelaxedPolicy(() -> getCacheDir(finalContext).getAbsolutePath()));
+    options.setCacheDirPath(getCacheDir(finalContext).getAbsolutePath());
 
     readDefaultOptionValues(options, finalContext, buildInfoProvider);
     AppState.getInstance().registerLifecycleObserver(options);
@@ -471,8 +466,7 @@ private static void readDefaultOptionValues(
 
     if (options.getDistinctId() == null) {
       try {
-        options.setDistinctId(
-            options.getRuntimeManager().runWithRelaxedPolicy(() -> Installation.id(context)));
+        options.setDistinctId(Installation.id(context));
       } catch (RuntimeException e) {
         options.getLogger().log(SentryLevel.ERROR, "Could not generate distinct Id.", e);
       }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
index ec60bd8f128..58d0a5a59d7 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
@@ -564,7 +564,7 @@ private void mergeUser(final @NotNull SentryBaseEvent event) {
 
   private @Nullable String getDeviceId() {
     try {
-      return options.getRuntimeManager().runWithRelaxedPolicy(() -> Installation.id(context));
+      return Installation.id(context);
     } catch (Throwable e) {
       options.getLogger().log(SentryLevel.ERROR, "Error getting installationId.", e);
     }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java
index 14cafab224d..7671935bb05 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java
@@ -174,7 +174,7 @@ private void mergeUser(final @NotNull SentryBaseEvent event) {
 
     // userId should be set even if event is Cached as the userId is static and won't change anyway.
     if (user.getId() == null) {
-      user.setId(options.getRuntimeManager().runWithRelaxedPolicy(() -> Installation.id(context)));
+      user.setId(Installation.id(context));
     }
     if (user.getIpAddress() == null && options.isSendDefaultPii()) {
       user.setIpAddress(IpAddressUtils.DEFAULT_IP_ADDRESS);
@@ -372,7 +372,7 @@ private void setAppExtras(final @NotNull App app, final @NotNull Hint hint) {
    */
   public @NotNull User getDefaultUser(final @NotNull Context context) {
     final @NotNull User user = new User();
-    user.setId(options.getRuntimeManager().runWithRelaxedPolicy(() -> Installation.id(context)));
+    user.setId(Installation.id(context));
     return user;
   }
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/DeviceInfoUtil.java b/sentry-android-core/src/main/java/io/sentry/android/core/DeviceInfoUtil.java
index 5c06a558103..f3b17c5854a 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/DeviceInfoUtil.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/DeviceInfoUtil.java
@@ -232,27 +232,21 @@ private void setDeviceIO(
     // this way of getting the size of storage might be problematic for storages bigger than 2GB
     // check the use of
     // https://developer.android.com/reference/java/io/File.html#getFreeSpace%28%29
-    options
-        .getRuntimeManager()
-        .runWithRelaxedPolicy(
-            () -> {
-              final @Nullable File dataDir = Environment.getDataDirectory();
-              if (dataDir != null) {
-                StatFs internalStorageStat = new StatFs(dataDir.getPath());
-                device.setStorageSize(getTotalInternalStorage(internalStorageStat));
-                device.setFreeStorage(getUnusedInternalStorage(internalStorageStat));
-              }
-
-              if (includeExternalStorage) {
-                final @Nullable File internalStorageFile = context.getExternalFilesDir(null);
-                final @Nullable StatFs externalStorageStat =
-                    getExternalStorageStat(internalStorageFile);
-                if (externalStorageStat != null) {
-                  device.setExternalStorageSize(getTotalExternalStorage(externalStorageStat));
-                  device.setExternalFreeStorage(getUnusedExternalStorage(externalStorageStat));
-                }
-              }
-            });
+    final @Nullable File dataDir = Environment.getDataDirectory();
+    if (dataDir != null) {
+      StatFs internalStorageStat = new StatFs(dataDir.getPath());
+      device.setStorageSize(getTotalInternalStorage(internalStorageStat));
+      device.setFreeStorage(getUnusedInternalStorage(internalStorageStat));
+    }
+
+    if (includeExternalStorage) {
+      final @Nullable File internalStorageFile = context.getExternalFilesDir(null);
+      final @Nullable StatFs externalStorageStat = getExternalStorageStat(internalStorageFile);
+      if (externalStorageStat != null) {
+        device.setExternalStorageSize(getTotalExternalStorage(externalStorageStat));
+        device.setExternalFreeStorage(getUnusedExternalStorage(externalStorageStat));
+      }
+    }
 
     if (device.getConnectionType() == null) {
       // wifi, ethernet or cellular, null if none
@@ -493,7 +487,7 @@ private Long getUnusedExternalStorage(final @NotNull StatFs stat) {
   @Nullable
   private String getDeviceId() {
     try {
-      return options.getRuntimeManager().runWithRelaxedPolicy(() -> Installation.id(context));
+      return Installation.id(context);
     } catch (Throwable e) {
       options.getLogger().log(SentryLevel.ERROR, "Error getting installationId.", e);
     }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/InternalSentrySdk.java b/sentry-android-core/src/main/java/io/sentry/android/core/InternalSentrySdk.java
index 7d0a7f77e58..cae558f0d43 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/InternalSentrySdk.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/InternalSentrySdk.java
@@ -102,8 +102,7 @@ public static Map<String, Object> serializeScope(
       }
       if (user.getId() == null) {
         try {
-          user.setId(
-              options.getRuntimeManager().runWithRelaxedPolicy(() -> Installation.id(context)));
+          user.setId(Installation.id(context));
         } catch (RuntimeException e) {
           logger.log(SentryLevel.ERROR, "Could not retrieve installation ID", e);
         }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
index d687670f9b6..7e43d626b34 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
@@ -20,12 +20,10 @@
 import io.sentry.SentryOptions;
 import io.sentry.TracesSampler;
 import io.sentry.TracesSamplingDecision;
-import io.sentry.android.core.internal.util.AndroidRuntimeManager;
 import io.sentry.android.core.internal.util.SentryFrameMetricsCollector;
 import io.sentry.android.core.performance.AppStartMetrics;
 import io.sentry.android.core.performance.TimeSpan;
 import io.sentry.util.AutoClosableReentrantLock;
-import io.sentry.util.runtime.IRuntimeManager;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
@@ -110,9 +108,7 @@ private void launchAppStartProfiler(final @NotNull AppStartMetrics appStartMetri
       return;
     }
 
-    final @NotNull IRuntimeManager runtimeManager = new AndroidRuntimeManager();
-    final @NotNull File cacheDir =
-        runtimeManager.runWithRelaxedPolicy(() -> AndroidOptionsInitializer.getCacheDir(context));
+    final @NotNull File cacheDir = AndroidOptionsInitializer.getCacheDir(context);
     final @NotNull File configFile = new File(cacheDir, APP_START_PROFILING_CONFIG_FILE_NAME);
 
     // No config exists: app start profiling is not enabled
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/cache/AndroidEnvelopeCache.java b/sentry-android-core/src/main/java/io/sentry/android/core/cache/AndroidEnvelopeCache.java
index 5aad7ef1b26..e1590e47943 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/cache/AndroidEnvelopeCache.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/cache/AndroidEnvelopeCache.java
@@ -125,10 +125,9 @@ public static boolean hasStartupCrashMarker(final @NotNull SentryOptions options
 
     final File crashMarkerFile = new File(outboxPath, STARTUP_CRASH_MARKER_FILE);
     try {
-      final boolean exists =
-          options.getRuntimeManager().runWithRelaxedPolicy(() -> crashMarkerFile.exists());
+      final boolean exists = crashMarkerFile.exists();
       if (exists) {
-        if (!options.getRuntimeManager().runWithRelaxedPolicy(() -> crashMarkerFile.delete())) {
+        if (!crashMarkerFile.delete()) {
           options
               .getLogger()
               .log(
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/AndroidRuntimeManager.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/AndroidRuntimeManager.java
deleted file mode 100644
index bed8d63ec11..00000000000
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/AndroidRuntimeManager.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package io.sentry.android.core.internal.util;
-
-import android.os.StrictMode;
-import io.sentry.util.runtime.IRuntimeManager;
-import org.jetbrains.annotations.ApiStatus;
-import org.jetbrains.annotations.NotNull;
-
-@ApiStatus.Internal
-public final class AndroidRuntimeManager implements IRuntimeManager {
-  @Override
-  public <T> T runWithRelaxedPolicy(final @NotNull IRuntimeManagerCallback<T> toRun) {
-    final @NotNull StrictMode.ThreadPolicy oldPolicy = StrictMode.getThreadPolicy();
-    final @NotNull StrictMode.VmPolicy oldVmPolicy = StrictMode.getVmPolicy();
-    StrictMode.setThreadPolicy(StrictMode.ThreadPolicy.LAX);
-    StrictMode.setVmPolicy(StrictMode.VmPolicy.LAX);
-    try {
-      return toRun.run();
-    } finally {
-      StrictMode.setThreadPolicy(oldPolicy);
-      StrictMode.setVmPolicy(oldVmPolicy);
-    }
-  }
-
-  @Override
-  public void runWithRelaxedPolicy(final @NotNull Runnable toRun) {
-    runWithRelaxedPolicy(
-        () -> {
-          toRun.run();
-          return null;
-        });
-  }
-}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
index 348075ff900..be54bf7768b 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
@@ -24,7 +24,6 @@ import io.sentry.android.core.internal.debugmeta.AssetsDebugMetaLoader
 import io.sentry.android.core.internal.gestures.AndroidViewGestureTargetLocator
 import io.sentry.android.core.internal.modules.AssetsModulesLoader
 import io.sentry.android.core.internal.util.AndroidConnectionStatusProvider
-import io.sentry.android.core.internal.util.AndroidRuntimeManager
 import io.sentry.android.core.internal.util.AndroidThreadChecker
 import io.sentry.android.core.performance.AppStartMetrics
 import io.sentry.android.fragment.FragmentLifecycleIntegration
@@ -930,10 +929,4 @@ class AndroidOptionsInitializerTest {
       fixture.sentryOptions.compositePerformanceCollector is DefaultCompositePerformanceCollector
     }
   }
-
-  @Test
-  fun `AndroidRuntimeManager is set in the options`() {
-    fixture.initSut()
-    assertIs<AndroidRuntimeManager>(fixture.sentryOptions.runtimeManager)
-  }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/AndroidRuntimeManagerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/AndroidRuntimeManagerTest.kt
deleted file mode 100644
index 6d1b8514c24..00000000000
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/AndroidRuntimeManagerTest.kt
+++ /dev/null
@@ -1,130 +0,0 @@
-package io.sentry.android.core.internal.util
-
-import android.os.StrictMode
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import kotlin.test.AfterTest
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNotEquals
-import kotlin.test.assertTrue
-import org.junit.runner.RunWith
-
-@RunWith(AndroidJUnit4::class)
-class AndroidRuntimeManagerTest {
-
-  val sut = AndroidRuntimeManager()
-
-  @AfterTest
-  fun `clean up`() {
-    // Revert StrictMode policies to avoid issues with other tests
-    StrictMode.setThreadPolicy(StrictMode.ThreadPolicy.LAX)
-    StrictMode.setVmPolicy(StrictMode.VmPolicy.LAX)
-  }
-
-  @Test
-  fun `runWithRelaxedPolicy changes policy when running and restores it afterwards`() {
-    var called = false
-    val threadPolicy = StrictMode.ThreadPolicy.Builder().detectAll().penaltyDeath().build()
-    val vmPolicy = StrictMode.VmPolicy.Builder().detectAll().penaltyDeath().build()
-    assertNotEquals(StrictMode.ThreadPolicy.LAX, threadPolicy)
-    assertNotEquals(StrictMode.VmPolicy.LAX, vmPolicy)
-
-    // Set and assert the StrictMode policies
-    StrictMode.setThreadPolicy(threadPolicy)
-    StrictMode.setVmPolicy(vmPolicy)
-    assertEquals(threadPolicy.toString(), StrictMode.getThreadPolicy().toString())
-    assertEquals(vmPolicy.toString(), StrictMode.getVmPolicy().toString())
-
-    // Run the function and assert LAX policies
-    called =
-      sut.runWithRelaxedPolicy<Boolean> {
-        assertEquals(
-          StrictMode.ThreadPolicy.LAX.toString(),
-          StrictMode.getThreadPolicy().toString(),
-        )
-        assertEquals(StrictMode.VmPolicy.LAX.toString(), StrictMode.getVmPolicy().toString())
-        true
-      }
-
-    // Policies should be reverted back
-    assertEquals(threadPolicy.toString(), StrictMode.getThreadPolicy().toString())
-    assertEquals(vmPolicy.toString(), StrictMode.getVmPolicy().toString())
-
-    // Ensure the code ran
-    assertTrue(called)
-  }
-
-  @Test
-  fun `runWithRelaxedPolicy changes policy and restores it afterwards even if the code throws`() {
-    var called = false
-    var exceptionPropagated = false
-    val threadPolicy = StrictMode.ThreadPolicy.Builder().detectAll().penaltyDeath().build()
-    val vmPolicy = StrictMode.VmPolicy.Builder().detectAll().penaltyDeath().build()
-
-    // Set and assert the StrictMode policies
-    StrictMode.setThreadPolicy(threadPolicy)
-    StrictMode.setVmPolicy(vmPolicy)
-
-    // Run the function and assert LAX policies
-    try {
-      sut.runWithRelaxedPolicy<Unit> {
-        assertEquals(
-          StrictMode.ThreadPolicy.LAX.toString(),
-          StrictMode.getThreadPolicy().toString(),
-        )
-        assertEquals(StrictMode.VmPolicy.LAX.toString(), StrictMode.getVmPolicy().toString())
-        called = true
-        throw Exception("Test exception")
-      }
-    } catch (e: Exception) {
-      assertEquals(e.message, "Test exception")
-      exceptionPropagated = true
-    }
-
-    // Policies should be reverted back
-    assertEquals(threadPolicy.toString(), StrictMode.getThreadPolicy().toString())
-    assertEquals(vmPolicy.toString(), StrictMode.getVmPolicy().toString())
-
-    // Ensure the code ran
-    assertTrue(called)
-    // Ensure the exception was propagated
-    assertTrue(exceptionPropagated)
-  }
-
-  @Test
-  fun `runWithRelaxedPolicy with Runnable changes policy when running and restores it afterwards even if the code throws`() {
-    var called = false
-    var exceptionPropagated = false
-    val threadPolicy = StrictMode.ThreadPolicy.Builder().detectAll().penaltyDeath().build()
-    val vmPolicy = StrictMode.VmPolicy.Builder().detectAll().penaltyDeath().build()
-
-    // Set and assert the StrictMode policies
-    StrictMode.setThreadPolicy(threadPolicy)
-    StrictMode.setVmPolicy(vmPolicy)
-
-    // Run the function and assert LAX policies
-    try {
-      sut.runWithRelaxedPolicy {
-        assertEquals(
-          StrictMode.ThreadPolicy.LAX.toString(),
-          StrictMode.getThreadPolicy().toString(),
-        )
-        assertEquals(StrictMode.VmPolicy.LAX.toString(), StrictMode.getVmPolicy().toString())
-        called = true
-        throw Exception("Test exception")
-      }
-    } catch (e: Exception) {
-      assertEquals(e.message, "Test exception")
-      exceptionPropagated = true
-    }
-
-    // Policies should be reverted back
-    assertEquals(threadPolicy.toString(), StrictMode.getThreadPolicy().toString())
-    assertEquals(vmPolicy.toString(), StrictMode.getVmPolicy().toString())
-
-    // Ensure the code ran
-    assertTrue(called)
-    // Ensure the exception was propagated
-    assertTrue(exceptionPropagated)
-  }
-}
diff --git a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/SdkInitTests.kt b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/SdkInitTests.kt
index 0bd5faf8d98..d3a60d2c198 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/SdkInitTests.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/SdkInitTests.kt
@@ -1,6 +1,5 @@
 package io.sentry.uitest.android
 
-import android.os.StrictMode
 import androidx.lifecycle.Lifecycle
 import androidx.test.core.app.launchActivity
 import androidx.test.ext.junit.runners.AndroidJUnit4
@@ -11,7 +10,6 @@ import io.sentry.android.core.AndroidLogger
 import io.sentry.android.core.CurrentActivityHolder
 import io.sentry.android.core.NdkIntegration
 import io.sentry.android.core.SentryAndroidOptions
-import io.sentry.assertEnvelopeEvent
 import io.sentry.assertEnvelopeTransaction
 import io.sentry.protocol.SentryTransaction
 import java.util.concurrent.CountDownLatch
@@ -254,54 +252,6 @@ class SdkInitTests : BaseUiTest() {
     assertDefaultIntegrations()
   }
 
-  @Test
-  fun initNotThrowStrictMode() {
-    StrictMode.setThreadPolicy(StrictMode.ThreadPolicy.Builder().detectAll().penaltyDeath().build())
-    StrictMode.setVmPolicy(
-      StrictMode.VmPolicy.Builder()
-        .detectActivityLeaks()
-        //        .detectCleartextNetwork() <- mockWebServer is on http, not https
-        .detectContentUriWithoutPermission()
-        .detectCredentialProtectedWhileLocked()
-        .detectFileUriExposure()
-        .detectImplicitDirectBoot()
-        .detectIncorrectContextUse()
-        .detectLeakedRegistrationObjects()
-        .detectLeakedSqlLiteObjects()
-        //        .detectNonSdkApiUsage() <- thrown by leakCanary
-        //        .detectUnsafeIntentLaunch() <- fails CI with java.lang.NoSuchMethodError
-        //        .detectUntaggedSockets() <- thrown by mockWebServer
-        .penaltyDeath()
-        .build()
-    )
-    initSentry(true) { it.tracesSampleRate = 1.0 }
-    val sampleScenario = launchActivity<EmptyActivity>()
-    relayIdlingResource.increment()
-    relayIdlingResource.increment()
-    Sentry.captureException(Exception("test"))
-    sampleScenario.moveToState(Lifecycle.State.DESTROYED)
-
-    // Avoid interferences with other tests and assertion logic
-    StrictMode.setThreadPolicy(StrictMode.ThreadPolicy.LAX)
-    StrictMode.setVmPolicy(StrictMode.VmPolicy.LAX)
-
-    relay.assert {
-      findEnvelope {
-          assertEnvelopeEvent(it.items.toList()).exceptions!!.any { it.value == "test" }
-        }
-        .assert {
-          it.assertEvent()
-          it.assertNoOtherItems()
-        }
-      findEnvelope { assertEnvelopeTransaction(it.items.toList()).transaction == "EmptyActivity" }
-        .assert {
-          it.assertTransaction()
-          it.assertNoOtherItems()
-        }
-      assertNoOtherEnvelopes()
-    }
-  }
-
   private fun assertDefaultIntegrations() {
     val integrations =
       mutableListOf(
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index c112e84608d..5554379644a 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -3564,7 +3564,6 @@ public class io/sentry/SentryOptions {
 	public fun getReadTimeoutMillis ()I
 	public fun getRelease ()Ljava/lang/String;
 	public fun getReplayController ()Lio/sentry/ReplayController;
-	public fun getRuntimeManager ()Lio/sentry/util/runtime/IRuntimeManager;
 	public fun getSampleRate ()Ljava/lang/Double;
 	public fun getScopeObservers ()Ljava/util/List;
 	public fun getSdkVersion ()Lio/sentry/protocol/SdkVersion;
@@ -3718,7 +3717,6 @@ public class io/sentry/SentryOptions {
 	public fun setReadTimeoutMillis (I)V
 	public fun setRelease (Ljava/lang/String;)V
 	public fun setReplayController (Lio/sentry/ReplayController;)V
-	public fun setRuntimeManager (Lio/sentry/util/runtime/IRuntimeManager;)V
 	public fun setSampleRate (Ljava/lang/Double;)V
 	public fun setSdkVersion (Lio/sentry/protocol/SdkVersion;)V
 	public fun setSendClientReports (Z)V
@@ -7812,21 +7810,6 @@ public final class io/sentry/util/network/ReplayNetworkRequestOrResponse {
 	public fun toString ()Ljava/lang/String;
 }
 
-public abstract interface class io/sentry/util/runtime/IRuntimeManager {
-	public abstract fun runWithRelaxedPolicy (Lio/sentry/util/runtime/IRuntimeManager$IRuntimeManagerCallback;)Ljava/lang/Object;
-	public abstract fun runWithRelaxedPolicy (Ljava/lang/Runnable;)V
-}
-
-public abstract interface class io/sentry/util/runtime/IRuntimeManager$IRuntimeManagerCallback {
-	public abstract fun run ()Ljava/lang/Object;
-}
-
-public final class io/sentry/util/runtime/NeutralRuntimeManager : io/sentry/util/runtime/IRuntimeManager {
-	public fun <init> ()V
-	public fun runWithRelaxedPolicy (Lio/sentry/util/runtime/IRuntimeManager$IRuntimeManagerCallback;)Ljava/lang/Object;
-	public fun runWithRelaxedPolicy (Ljava/lang/Runnable;)V
-}
-
 public abstract interface class io/sentry/util/thread/IThreadChecker {
 	public abstract fun currentThreadSystemId ()J
 	public abstract fun getCurrentThreadName ()Ljava/lang/String;
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index ff84b151658..8acc051f522 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -612,7 +612,7 @@ private static void initConfigurations(final @NotNull SentryOptions options) {
     final String outboxPath = options.getOutboxPath();
     if (outboxPath != null) {
       final File outboxDir = new File(outboxPath);
-      options.getRuntimeManager().runWithRelaxedPolicy(() -> outboxDir.mkdirs());
+      outboxDir.mkdirs();
     } else {
       logger.log(SentryLevel.INFO, "No outbox dir path is defined in options.");
     }
@@ -620,7 +620,7 @@ private static void initConfigurations(final @NotNull SentryOptions options) {
     final String cacheDirPath = options.getCacheDirPath();
     if (cacheDirPath != null) {
       final File cacheDir = new File(cacheDirPath);
-      options.getRuntimeManager().runWithRelaxedPolicy(() -> cacheDir.mkdirs());
+      cacheDir.mkdirs();
       final IEnvelopeCache envelopeCache = options.getEnvelopeDiskCache();
       // only overwrite the cache impl if it's not already set
       if (envelopeCache instanceof NoOpEnvelopeCache) {
@@ -633,7 +633,7 @@ private static void initConfigurations(final @NotNull SentryOptions options) {
         && profilingTracesDirPath != null) {
 
       final File profilingTracesDir = new File(profilingTracesDirPath);
-      options.getRuntimeManager().runWithRelaxedPolicy(() -> profilingTracesDir.mkdirs());
+      profilingTracesDir.mkdirs();
 
       try {
         options
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 7b21661c223..b89ec1a0e71 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -31,8 +31,6 @@
 import io.sentry.util.Platform;
 import io.sentry.util.SampleRateUtils;
 import io.sentry.util.StringUtils;
-import io.sentry.util.runtime.IRuntimeManager;
-import io.sentry.util.runtime.NeutralRuntimeManager;
 import io.sentry.util.thread.IThreadChecker;
 import io.sentry.util.thread.NoOpThreadChecker;
 import java.io.File;
@@ -640,9 +638,6 @@ public class SentryOptions {
 
   private @NotNull ISocketTagger socketTagger = NoOpSocketTagger.getInstance();
 
-  /** Runtime manager to manage runtime policies, like StrictMode on Android. */
-  private @NotNull IRuntimeManager runtimeManager = new NeutralRuntimeManager();
-
   private @Nullable String profilingTracesDirPath;
 
   public @NotNull IProfileConverter getProfilerConverter() {
@@ -3158,26 +3153,6 @@ public void setSocketTagger(final @Nullable ISocketTagger socketTagger) {
     this.socketTagger = socketTagger != null ? socketTagger : NoOpSocketTagger.getInstance();
   }
 
-  /**
-   * Returns the IRuntimeManager
-   *
-   * @return the runtime manager
-   */
-  @ApiStatus.Internal
-  public @NotNull IRuntimeManager getRuntimeManager() {
-    return runtimeManager;
-  }
-
-  /**
-   * Sets the IRuntimeManager
-   *
-   * @param runtimeManager the runtime manager
-   */
-  @ApiStatus.Internal
-  public void setRuntimeManager(final @NotNull IRuntimeManager runtimeManager) {
-    this.runtimeManager = runtimeManager;
-  }
-
   /**
    * 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.
diff --git a/sentry/src/main/java/io/sentry/util/runtime/IRuntimeManager.java b/sentry/src/main/java/io/sentry/util/runtime/IRuntimeManager.java
deleted file mode 100644
index ec0f8b05baf..00000000000
--- a/sentry/src/main/java/io/sentry/util/runtime/IRuntimeManager.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package io.sentry.util.runtime;
-
-import org.jetbrains.annotations.ApiStatus;
-import org.jetbrains.annotations.NotNull;
-
-@ApiStatus.Internal
-public interface IRuntimeManager {
-  <T> T runWithRelaxedPolicy(final @NotNull IRuntimeManagerCallback<T> toRun);
-
-  void runWithRelaxedPolicy(final @NotNull Runnable toRun);
-
-  interface IRuntimeManagerCallback<T> {
-    T run();
-  }
-}
diff --git a/sentry/src/main/java/io/sentry/util/runtime/NeutralRuntimeManager.java b/sentry/src/main/java/io/sentry/util/runtime/NeutralRuntimeManager.java
deleted file mode 100644
index 36dd061612c..00000000000
--- a/sentry/src/main/java/io/sentry/util/runtime/NeutralRuntimeManager.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package io.sentry.util.runtime;
-
-import org.jetbrains.annotations.ApiStatus;
-import org.jetbrains.annotations.NotNull;
-
-@ApiStatus.Internal
-public final class NeutralRuntimeManager implements IRuntimeManager {
-  @Override
-  public <T> T runWithRelaxedPolicy(final @NotNull IRuntimeManagerCallback<T> toRun) {
-    return toRun.run();
-  }
-
-  @Override
-  public void runWithRelaxedPolicy(final @NotNull Runnable toRun) {
-    toRun.run();
-  }
-}
diff --git a/sentry/src/test/java/io/sentry/util/runtime/NeutralRuntimeManagerTest.kt b/sentry/src/test/java/io/sentry/util/runtime/NeutralRuntimeManagerTest.kt
deleted file mode 100644
index faafd4a8c38..00000000000
--- a/sentry/src/test/java/io/sentry/util/runtime/NeutralRuntimeManagerTest.kt
+++ /dev/null
@@ -1,61 +0,0 @@
-package io.sentry.util.runtime
-
-import java.io.IOException
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertTrue
-
-class NeutralRuntimeManagerTest {
-
-  val sut = NeutralRuntimeManager()
-
-  @Test
-  fun `runWithRelaxedPolicy runs the code`() {
-    var called = false
-
-    called = sut.runWithRelaxedPolicy<Boolean> { true }
-
-    // Ensure the code ran
-    assertTrue(called)
-  }
-
-  @Test
-  fun `runWithRelaxedPolicy with runnable runs the code`() {
-    var called = false
-
-    sut.runWithRelaxedPolicy { called = true }
-
-    // Ensure the code ran
-    assertTrue(called)
-  }
-
-  @Test
-  fun `runWithRelaxedPolicy propagates exception`() {
-    var exceptionPropagated = false
-
-    try {
-      sut.runWithRelaxedPolicy<Unit> { throw IOException("test") }
-    } catch (e: IOException) {
-      assertEquals("test", e.message)
-      exceptionPropagated = true
-    }
-
-    // Ensure the exception was propagated
-    assertTrue(exceptionPropagated)
-  }
-
-  @Test
-  fun `runWithRelaxedPolicy with runnable propagates exception`() {
-    var exceptionPropagated = false
-
-    try {
-      sut.runWithRelaxedPolicy { throw IOException("test") }
-    } catch (e: IOException) {
-      assertEquals("test", e.message)
-      exceptionPropagated = true
-    }
-
-    // Ensure the exception was propagated
-    assertTrue(exceptionPropagated)
-  }
-}

From 0dd3823ddb6426aa1da133725ea211bc2bf30c04 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Tue, 3 Mar 2026 12:02:23 +0100
Subject: [PATCH 025/391] chore(changelog): Add a warning about strictmode
 violations (#5144)

Added important note about StrictMode violations in debug builds.
---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 35aa59686f4..df9ab83e39e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -31,6 +31,7 @@
 ### Fixes
 
 - Remove `AndroidRuntimeManager` StrictMode relaxation to prevent ANRs during SDK init ([#5127](https://github.com/getsentry/sentry-java/pull/5127))
+  - **IMPORTANT:** StrictMode violations may appear again in debug builds. This is intentional to prevent ANRs in production releases.
 - Fix crash when unregistering `SystemEventsBroadcastReceiver` with try-catch block. ([#5106](https://github.com/getsentry/sentry-java/pull/5106))
 - Log an actionable error message when Relay returns HTTP 413 (Content Too Large) ([#5115](https://github.com/getsentry/sentry-java/pull/5115))
   - Also switch the client report discard reason for all HTTP 4xx/5xx errors (except 429) from `network_error` to `send_error`

From 01221e2da958c49289e6fd711d807b8ad0337ccc Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Tue, 3 Mar 2026 12:21:46 +0100
Subject: [PATCH 026/391] fix(gestures): Use peekDecorView to not force view
 hierarchy construction (#5134)

* fix(gestures): Use peekDecorView to not force view hierarchy construction

* fix(gestures): Add changelog entry for peekDecorView fix

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../gestures/SentryGestureListener.java       |  2 +-
 .../SentryGestureListenerPeekDecorViewTest.kt | 48 +++++++++++++++++++
 .../core/internal/gestures/ViewHelpers.kt     |  2 +-
 4 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureListenerPeekDecorViewTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index df9ab83e39e..ccff564763f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -33,6 +33,7 @@
 - Remove `AndroidRuntimeManager` StrictMode relaxation to prevent ANRs during SDK init ([#5127](https://github.com/getsentry/sentry-java/pull/5127))
   - **IMPORTANT:** StrictMode violations may appear again in debug builds. This is intentional to prevent ANRs in production releases.
 - Fix crash when unregistering `SystemEventsBroadcastReceiver` with try-catch block. ([#5106](https://github.com/getsentry/sentry-java/pull/5106))
+- Use `peekDecorView` instead of `getDecorView` in `SentryGestureListener` to avoid forcing view hierarchy construction ([#5134](https://github.com/getsentry/sentry-java/pull/5134))
 - Log an actionable error message when Relay returns HTTP 413 (Content Too Large) ([#5115](https://github.com/getsentry/sentry-java/pull/5115))
   - Also switch the client report discard reason for all HTTP 4xx/5xx errors (except 429) from `network_error` to `send_error`
 - Trim DSN string before parsing to avoid `URISyntaxException` caused by trailing whitespace ([#5113](https://github.com/getsentry/sentry-java/pull/5113))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureListener.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureListener.java
index cd89db72f53..8caffedad94 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureListener.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureListener.java
@@ -347,7 +347,7 @@ void applyScope(final @NotNull IScope scope, final @NotNull ITransaction transac
       return null;
     }
 
-    final View decorView = window.getDecorView();
+    final View decorView = window.peekDecorView();
     if (decorView == null) {
       options
           .getLogger()
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureListenerPeekDecorViewTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureListenerPeekDecorViewTest.kt
new file mode 100644
index 00000000000..7b26aa55c79
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureListenerPeekDecorViewTest.kt
@@ -0,0 +1,48 @@
+package io.sentry.android.core.internal.gestures
+
+import android.app.Activity
+import android.view.MotionEvent
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.Breadcrumb
+import io.sentry.IScopes
+import io.sentry.android.core.SentryAndroidOptions
+import io.sentry.util.LazyEvaluator
+import kotlin.test.Test
+import kotlin.test.assertNull
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+import org.robolectric.Robolectric.buildActivity
+
+@RunWith(AndroidJUnit4::class)
+class SentryGestureListenerPeekDecorViewTest {
+
+  @Test
+  fun `does not force decor view creation when peekDecorView returns null`() {
+    // A plain Activity that never calls setContentView — peekDecorView() should return null
+    val activity = buildActivity(Activity::class.java).create().get()
+
+    // Sanity check: decor view has not been created yet
+    assertNull(activity.window.peekDecorView())
+
+    val scopes = mock<IScopes>()
+    val options =
+      SentryAndroidOptions().apply {
+        isEnableUserInteractionBreadcrumbs = true
+        gestureTargetLocators = listOf(AndroidViewGestureTargetLocator(LazyEvaluator { true }))
+        dsn = "https://key@sentry.io/proj"
+      }
+
+    val sut = SentryGestureListener(activity, scopes, options)
+    sut.onSingleTapUp(mock<MotionEvent>())
+
+    // The key assertion: peekDecorView is still null — we did not force view hierarchy creation
+    assertNull(activity.window.peekDecorView())
+
+    // And no breadcrumb was captured
+    verify(scopes, never()).addBreadcrumb(any<Breadcrumb>(), anyOrNull())
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewHelpers.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewHelpers.kt
index 86123d0a3a2..1a4f28bbe35 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewHelpers.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewHelpers.kt
@@ -22,7 +22,7 @@ internal inline fun <reified T : View> Window.mockDecorView(
   finalize: (T) -> Unit = {},
 ): T {
   val view = mockView(id, event, touchWithinBounds, clickable, visible, context, finalize)
-  whenever(decorView).doReturn(view)
+  whenever(peekDecorView()).doReturn(view)
   return view
 }
 

From b8bd88061259ff86c9472d203d3f17d1c106336e Mon Sep 17 00:00:00 2001
From: Stefan Jandl <reg@bitfox.at>
Date: Tue, 3 Mar 2026 16:47:42 +0100
Subject: [PATCH 027/391] feat: Made `ManifestMetaDataReader` read the `DIST`
 (#5107)

---
 CHANGELOG.md                                  |  1 +
 .../android/core/ManifestMetadataReader.java  |  3 +++
 .../core/ManifestMetadataReaderTest.kt        | 25 +++++++++++++++++++
 3 files changed, 29 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ccff564763f..e7485668864 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -27,6 +27,7 @@
     <meta-data android:name="io.sentry.screenshot.mask-all-text" android:value="true" />
     <meta-data android:name="io.sentry.screenshot.mask-all-images" android:value="true" />
     ```
+- The `ManifestMetaDataReader` now read the `DIST` ([#5107](https://github.com/getsentry/sentry-java/pull/5107))
 
 ### Fixes
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 66587925404..0fd217794e2 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -41,6 +41,7 @@ final class ManifestMetadataReader {
   static final String NDK_SCOPE_SYNC_ENABLE = "io.sentry.ndk.scope-sync.enable";
   static final String NDK_SDK_NAME = "io.sentry.ndk.sdk-name";
   static final String RELEASE = "io.sentry.release";
+  static final String DIST = "io.sentry.dist";
   static final String ENVIRONMENT = "io.sentry.environment";
   static final String SDK_NAME = "io.sentry.sdk.name";
   static final String SDK_VERSION = "io.sentry.sdk.version";
@@ -273,6 +274,8 @@ static void applyMetadata(
 
         options.setRelease(readString(metadata, logger, RELEASE, options.getRelease()));
 
+        options.setDist(readString(metadata, logger, DIST, options.getDist()));
+
         options.setEnvironment(readString(metadata, logger, ENVIRONMENT, options.getEnvironment()));
 
         options.setSessionTrackingIntervalMillis(
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index c8e55ffc095..fd5c9cffc89 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -187,6 +187,31 @@ class ManifestMetadataReaderTest {
     assertNull(fixture.options.release)
   }
 
+  @Test
+  fun `applyMetadata reads dist to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.DIST to "test-dist")
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals("test-dist", fixture.options.dist)
+  }
+
+  @Test
+  fun `applyMetadata reads dist and keep default value if not found`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertNull(fixture.options.dist)
+  }
+
   @Test
   fun `applyMetadata reads session tracking interval to options`() {
     // Arrange

From 815e0348f1511456e4c377fcf76de0f08177eab8 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 4 Mar 2026 09:16:12 +0100
Subject: [PATCH 028/391] feat(options): Add support for `SENTRY_SAMPLE_RATE`
 environment variable / `sample-rate` property (#5112)

* feat: Add support for SENTRY_SAMPLE_RATE environment variable

Add `sampleRate` to `ExternalOptions` so it can be configured via the
`SENTRY_SAMPLE_RATE` environment variable or `sample-rate` property,
matching the behavior of other sample rate options.

Fixes GH-5091
Co-Authored-By: Claude <noreply@anthropic.com>

* docs: Add changelog entry for SENTRY_SAMPLE_RATE support

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                          |  1 +
 sentry/api/sentry.api                                 |  2 ++
 sentry/src/main/java/io/sentry/ExternalOptions.java   | 10 ++++++++++
 sentry/src/main/java/io/sentry/SentryOptions.java     |  3 +++
 sentry/src/test/java/io/sentry/ExternalOptionsTest.kt |  5 +++++
 sentry/src/test/java/io/sentry/SentryOptionsTest.kt   |  2 ++
 6 files changed, 23 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e7485668864..fb4de5057c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Features
 
+- Add support for `SENTRY_SAMPLE_RATE` environment variable / `sample-rate` property ([#5112](https://github.com/getsentry/sentry-java/pull/5112))
 - Create `sentry-opentelemetry-otlp` and `sentry-opentelemetry-otlp-spring` modules for combining OpenTelemetry SDK OTLP export with Sentry SDK ([#5100](https://github.com/getsentry/sentry-java/pull/5100))
   - OpenTelemetry is configured to send spans to Sentry directly using an OTLP endpoint.
   - Sentry only uses trace and span ID from OpenTelemetry (via `OpenTelemetryOtlpEventProcessor`) but will not send spans through OpenTelemetry nor use OpenTelemetry `Context` for `Scopes` propagation.
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 5554379644a..9b8413630c2 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -504,6 +504,7 @@ public final class io/sentry/ExternalOptions {
 	public fun getProguardUuid ()Ljava/lang/String;
 	public fun getProxy ()Lio/sentry/SentryOptions$Proxy;
 	public fun getRelease ()Ljava/lang/String;
+	public fun getSampleRate ()Ljava/lang/Double;
 	public fun getSendClientReports ()Ljava/lang/Boolean;
 	public fun getServerName ()Ljava/lang/String;
 	public fun getSpotlightConnectionUrl ()Ljava/lang/String;
@@ -552,6 +553,7 @@ public final class io/sentry/ExternalOptions {
 	public fun setProguardUuid (Ljava/lang/String;)V
 	public fun setProxy (Lio/sentry/SentryOptions$Proxy;)V
 	public fun setRelease (Ljava/lang/String;)V
+	public fun setSampleRate (Ljava/lang/Double;)V
 	public fun setSendClientReports (Ljava/lang/Boolean;)V
 	public fun setSendDefaultPii (Ljava/lang/Boolean;)V
 	public fun setSendModules (Ljava/lang/Boolean;)V
diff --git a/sentry/src/main/java/io/sentry/ExternalOptions.java b/sentry/src/main/java/io/sentry/ExternalOptions.java
index b5604e2b49b..9eaf26b202f 100644
--- a/sentry/src/main/java/io/sentry/ExternalOptions.java
+++ b/sentry/src/main/java/io/sentry/ExternalOptions.java
@@ -23,6 +23,7 @@ public final class ExternalOptions {
   private @Nullable Boolean enableUncaughtExceptionHandler;
   private @Nullable Boolean debug;
   private @Nullable Boolean enableDeduplication;
+  private @Nullable Double sampleRate;
   private @Nullable Double tracesSampleRate;
   private @Nullable Double profilesSampleRate;
   private @Nullable SentryOptions.RequestSize maxRequestBodySize;
@@ -77,6 +78,7 @@ public final class ExternalOptions {
         propertiesProvider.getBooleanProperty("uncaught.handler.enabled"));
     options.setPrintUncaughtStackTrace(
         propertiesProvider.getBooleanProperty("uncaught.handler.print-stacktrace"));
+    options.setSampleRate(propertiesProvider.getDoubleProperty("sample-rate"));
     options.setTracesSampleRate(propertiesProvider.getDoubleProperty("traces-sample-rate"));
     options.setProfilesSampleRate(propertiesProvider.getDoubleProperty("profiles-sample-rate"));
     options.setDebug(propertiesProvider.getBooleanProperty("debug"));
@@ -295,6 +297,14 @@ public void setEnableDeduplication(final @Nullable Boolean enableDeduplication)
     this.enableDeduplication = enableDeduplication;
   }
 
+  public @Nullable Double getSampleRate() {
+    return sampleRate;
+  }
+
+  public void setSampleRate(final @Nullable Double sampleRate) {
+    this.sampleRate = sampleRate;
+  }
+
   public @Nullable Double getTracesSampleRate() {
     return tracesSampleRate;
   }
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index b89ec1a0e71..7883ed6b95b 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -3378,6 +3378,9 @@ public void merge(final @NotNull ExternalOptions options) {
     if (options.getPrintUncaughtStackTrace() != null) {
       setPrintUncaughtStackTrace(options.getPrintUncaughtStackTrace());
     }
+    if (options.getSampleRate() != null) {
+      setSampleRate(options.getSampleRate());
+    }
     if (options.getTracesSampleRate() != null) {
       setTracesSampleRate(options.getTracesSampleRate());
     }
diff --git a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
index 1276d58fdbb..5a8bb1c7872 100644
--- a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
@@ -101,6 +101,11 @@ class ExternalOptionsTest {
     }
   }
 
+  @Test
+  fun `creates options with sampleRate using external properties`() {
+    withPropertiesFile("sample-rate=0.2") { assertEquals(0.2, it.sampleRate) }
+  }
+
   @Test
   fun `creates options with tracesSampleRate using external properties`() {
     withPropertiesFile("traces-sample-rate=0.2") { assertEquals(0.2, it.tracesSampleRate) }
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index 80510db931f..2f5b3579cb3 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -376,6 +376,7 @@ class SentryOptionsTest {
     externalOptions.setTag("tag1", "value1")
     externalOptions.setTag("tag2", "value2")
     externalOptions.enableUncaughtExceptionHandler = false
+    externalOptions.sampleRate = 0.3
     externalOptions.tracesSampleRate = 0.5
     externalOptions.profilesSampleRate = 0.5
     externalOptions.addInAppInclude("com.app")
@@ -433,6 +434,7 @@ class SentryOptionsTest {
     assertEquals(java.net.Proxy.Type.SOCKS, options.proxy!!.type)
     assertEquals(mapOf("tag1" to "value1", "tag2" to "value2"), options.tags)
     assertFalse(options.isEnableUncaughtExceptionHandler)
+    assertEquals(0.3, options.sampleRate)
     assertEquals(0.5, options.tracesSampleRate)
     assertEquals(0.5, options.profilesSampleRate)
     assertEquals(listOf("com.app"), options.inAppIncludes)

From 4b1510b40662a2a659349416da2eae5caa61a8c2 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 4 Mar 2026 09:56:18 +0100
Subject: [PATCH 029/391] feat(core): Global Attributes API (#5148)

* feat(core): Add scope-level attributes API

Add setAttribute, setAttributes, removeAttribute, and getAttributes
to IScope/IScopes/Sentry so users can set attributes on the scope
that are automatically included in logs and metrics events.

Also refactor type inference logic into SentryAttributeType.inferFrom
and add SentryLogEventAttributeValue.fromAttribute factory method,
removing duplicate getType helpers from LoggerApi and MetricsApi.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* ref: Split out LoggerApi/MetricsApi changes for stacked PR

Move factory method extractions (SentryAttributeType.inferFrom,
SentryLogEventAttributeValue.fromAttribute) and LoggerApi/MetricsApi
scope attribute integration to a separate stacked PR.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(core): Wire scope attributes into LoggerApi and MetricsApi

Extract factory methods SentryAttributeType.inferFrom and
SentryLogEventAttributeValue.fromAttribute to reduce duplication.
Apply scope attributes to log and metric events automatically.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* feat(samples): Showcase scope attributes in Spring Boot 4 samples

Add Sentry.setAttribute() calls to PersonController and
MetricController across all Spring Boot 4 sample variants to
demonstrate scope attributes being auto-attached to logs and metrics.

Add e2e test assertions and TestHelper methods to verify scope
attributes appear on captured log and metric events.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* Revert "changelog"

This reverts commit 7189bdca1a211085608f16bf3443c9e6675b6680.

* ref: Remove redundant comments from variant controllers

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref: Limit scope attributes sample to base Spring Boot 4 variant

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: Detect integer attribute type correctly for all integer Number subtypes

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* feat: Support collections and arrays in log attribute type inference

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* use ConcurrentHashMap instead of HashMap when merging attributes

* add enabled check similar to tags

* make setAttribute and setAttributes params nullable

* test: Add coverage for arrayAttribute factory method

Add arrayAttribute and named array attribute usage to the four
attribute tests in ScopesTest (log, count metric, distribution metric,
gauge metric) to verify the factory method works end-to-end.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat: Add Object[] overload to arrayAttribute factory

The arrayAttribute() factory only accepted Collection<?>, but
inferFrom() also handles native Java arrays. Add an Object[] overload
so users can pass object arrays like String[] directly without
falling back to the untyped named() method.

Co-Authored-By: Claude <noreply@anthropic.com>

* shape changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   5 +
 .../spring/boot4/MetricController.java        |   2 +
 .../spring/boot4/PersonController.java        |   4 +
 .../io/sentry/systemtest/MetricsSystemTest.kt |   4 +-
 .../io/sentry/systemtest/PersonSystemTest.kt  |  15 ++-
 .../api/sentry-system-test-support.api        |   2 +
 .../io/sentry/systemtest/util/TestHelper.kt   |  62 +++++++++
 sentry/api/sentry.api                         |  57 ++++++++
 .../java/io/sentry/CombinedScopeView.java     |  29 +++++
 .../src/main/java/io/sentry/HubAdapter.java   |  20 +++
 .../main/java/io/sentry/HubScopesWrapper.java |  20 +++
 sentry/src/main/java/io/sentry/IScope.java    |  38 ++++++
 sentry/src/main/java/io/sentry/IScopes.java   |  29 +++++
 sentry/src/main/java/io/sentry/NoOpHub.java   |  12 ++
 sentry/src/main/java/io/sentry/NoOpScope.java |  18 +++
 .../src/main/java/io/sentry/NoOpScopes.java   |  12 ++
 sentry/src/main/java/io/sentry/Scope.java     |  70 ++++++++++
 sentry/src/main/java/io/sentry/Scopes.java    |  50 +++++++
 .../main/java/io/sentry/ScopesAdapter.java    |  20 +++
 sentry/src/main/java/io/sentry/Sentry.java    |  37 ++++++
 .../main/java/io/sentry/SentryAttribute.java  |  11 ++
 .../java/io/sentry/SentryAttributeType.java   |  30 ++++-
 .../sentry/SentryLogEventAttributeValue.java  |  15 +++
 .../main/java/io/sentry/logger/LoggerApi.java |  29 ++---
 .../java/io/sentry/metrics/MetricsApi.java    |  27 ++--
 .../java/io/sentry/CombinedScopeViewTest.kt   |  67 ++++++++++
 sentry/src/test/java/io/sentry/ScopeTest.kt   | 104 +++++++++++++++
 sentry/src/test/java/io/sentry/ScopesTest.kt  |  84 ++++++++++++
 .../java/io/sentry/SentryAttributeTypeTest.kt | 122 ++++++++++++++++++
 .../protocol/SentryLogsSerializationTest.kt   |   1 +
 .../src/test/resources/json/sentry_logs.json  |   5 +
 31 files changed, 963 insertions(+), 38 deletions(-)
 create mode 100644 sentry/src/test/java/io/sentry/SentryAttributeTypeTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fb4de5057c6..4353044f84e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@
 
 ### Features
 
+- Add scope-level attributes API ([#5118](https://github.com/getsentry/sentry-java/pull/5118)) via ([#5148](https://github.com/getsentry/sentry-java/pull/5148))
+  - Automatically include scope attributes in logs and metrics ([#5120](https://github.com/getsentry/sentry-java/pull/5120))
+  - New APIs are `Sentry.setAttribute`, `Sentry.setAttributes`, `Sentry.removeAttribute`
+- Support collections and arrays in attribute type inference ([#5124](https://github.com/getsentry/sentry-java/pull/5124))
 - Add support for `SENTRY_SAMPLE_RATE` environment variable / `sample-rate` property ([#5112](https://github.com/getsentry/sentry-java/pull/5112))
 - Create `sentry-opentelemetry-otlp` and `sentry-opentelemetry-otlp-spring` modules for combining OpenTelemetry SDK OTLP export with Sentry SDK ([#5100](https://github.com/getsentry/sentry-java/pull/5100))
   - OpenTelemetry is configured to send spans to Sentry directly using an OTLP endpoint.
@@ -32,6 +36,7 @@
 
 ### Fixes
 
+- Fix attribute type detection for `Long`, `Short`, `Byte`, `BigInteger`, `AtomicInteger`, and `AtomicLong` being incorrectly inferred as `double` instead of `integer` ([#5122](https://github.com/getsentry/sentry-java/pull/5122))
 - Remove `AndroidRuntimeManager` StrictMode relaxation to prevent ANRs during SDK init ([#5127](https://github.com/getsentry/sentry-java/pull/5127))
   - **IMPORTANT:** StrictMode violations may appear again in debug builds. This is intentional to prevent ANRs in production releases.
 - Fix crash when unregistering `SystemEventsBroadcastReceiver` with try-catch block. ([#5106](https://github.com/getsentry/sentry-java/pull/5106))
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/MetricController.java b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
index 2a969ec8849..be75f5e3002 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/PersonController.java b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
index c65c9040d5c..489dc629d28 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
@@ -27,6 +27,10 @@ Person person(@PathVariable Long id) {
     ISpan currentSpan = Sentry.getSpan();
     ISpan sentrySpan = currentSpan.startChild("spanCreatedThroughSentryApi");
     try {
+      Sentry.setAttribute("user.type", "admin");
+      Sentry.setAttribute("feature.version", 2);
+      Sentry.setAttribute("debug.enabled", true);
+
       Sentry.logger().warn("warn Sentry logging");
       Sentry.logger().error("error Sentry logging");
       Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index 362a8577148..2389734a8b3 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -50,7 +50,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-system-test-support/api/sentry-system-test-support.api b/sentry-system-test-support/api/sentry-system-test-support.api
index ff620c7d809..51ef7da55d9 100644
--- a/sentry-system-test-support/api/sentry-system-test-support.api
+++ b/sentry-system-test-support/api/sentry-system-test-support.api
@@ -574,6 +574,8 @@ public final class io/sentry/systemtest/util/TestHelper {
 	public static synthetic fun doesContainMetric$default (Lio/sentry/systemtest/util/TestHelper;Lio/sentry/SentryMetricsEvents;Ljava/lang/String;Ljava/lang/String;DLjava/lang/String;ILjava/lang/Object;)Z
 	public final fun doesEventHaveExceptionMessage (Lio/sentry/SentryEvent;Ljava/lang/String;)Z
 	public final fun doesEventHaveFlag (Lio/sentry/SentryEvent;Ljava/lang/String;Z)Z
+	public final fun doesLogWithBodyHaveAttribute (Lio/sentry/SentryLogEvents;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)Z
+	public final fun doesMetricHaveAttribute (Lio/sentry/SentryMetricsEvents;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)Z
 	public final fun doesTransactionContainSpanWithDescription (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;)Z
 	public final fun doesTransactionContainSpanWithOp (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;)Z
 	public final fun doesTransactionContainSpanWithOpAndDescription (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;Ljava/lang/String;)Z
diff --git a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/TestHelper.kt b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/TestHelper.kt
index 2881460a2d0..19817c34ac8 100644
--- a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/TestHelper.kt
+++ b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/TestHelper.kt
@@ -190,6 +190,68 @@ class TestHelper(backendUrl: String) {
     return true
   }
 
+  fun doesLogWithBodyHaveAttribute(
+    logs: SentryLogEvents,
+    body: String,
+    attributeKey: String,
+    attributeValue: Any?,
+  ): Boolean {
+    val logItem = logs.items.firstOrNull { logItem -> logItem.body == body }
+    if (logItem == null) {
+      println("Unable to find log item with body $body in logs:")
+      logObject(logs)
+      return false
+    }
+
+    val attr = logItem.attributes?.get(attributeKey)
+    if (attr == null) {
+      println("Unable to find attribute $attributeKey on log with body $body:")
+      logObject(logItem)
+      return false
+    }
+
+    if (attr.value != attributeValue) {
+      println(
+        "Attribute $attributeKey has value ${attr.value} but expected $attributeValue on log with body $body:"
+      )
+      logObject(logItem)
+      return false
+    }
+
+    return true
+  }
+
+  fun doesMetricHaveAttribute(
+    metrics: SentryMetricsEvents,
+    metricName: String,
+    attributeKey: String,
+    attributeValue: Any?,
+  ): Boolean {
+    val metricItem = metrics.items.firstOrNull { it.name == metricName }
+    if (metricItem == null) {
+      println("Unable to find metric with name $metricName in metrics:")
+      logObject(metrics)
+      return false
+    }
+
+    val attr = metricItem.attributes?.get(attributeKey)
+    if (attr == null) {
+      println("Unable to find attribute $attributeKey on metric $metricName:")
+      logObject(metricItem)
+      return false
+    }
+
+    if (attr.value != attributeValue) {
+      println(
+        "Attribute $attributeKey has value ${attr.value} but expected $attributeValue on metric $metricName:"
+      )
+      logObject(metricItem)
+      return false
+    }
+
+    return true
+  }
+
   private fun checkIfTransactionMatches(
     envelopeString: String,
     callback: ((SentryTransaction, SentryEnvelopeHeader) -> Boolean),
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 9b8413630c2..a7bbb6c6cfa 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -276,6 +276,7 @@ public final class io/sentry/CombinedScopeView : io/sentry/IScope {
 	public synthetic fun clone ()Ljava/lang/Object;
 	public fun endSession ()Lio/sentry/Session;
 	public fun getAttachments ()Ljava/util/List;
+	public fun getAttributes ()Ljava/util/Map;
 	public fun getBreadcrumbs ()Ljava/util/Queue;
 	public fun getClient ()Lio/sentry/ISentryClient;
 	public fun getContexts ()Lio/sentry/protocol/Contexts;
@@ -298,11 +299,15 @@ public final class io/sentry/CombinedScopeView : io/sentry/IScope {
 	public fun getTransaction ()Lio/sentry/ITransaction;
 	public fun getTransactionName ()Ljava/lang/String;
 	public fun getUser ()Lio/sentry/protocol/User;
+	public fun removeAttribute (Ljava/lang/String;)V
 	public fun removeContexts (Ljava/lang/String;)V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun replaceOptions (Lio/sentry/SentryOptions;)V
 	public fun setActiveSpan (Lio/sentry/ISpan;)V
+	public fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public fun setContexts (Ljava/lang/String;Ljava/lang/Boolean;)V
 	public fun setContexts (Ljava/lang/String;Ljava/lang/Character;)V
 	public fun setContexts (Ljava/lang/String;Ljava/lang/Number;)V
@@ -672,10 +677,14 @@ public final class io/sentry/HubAdapter : io/sentry/IHub {
 	public fun popScope ()V
 	public fun pushIsolationScope ()Lio/sentry/ISentryLifecycleToken;
 	public fun pushScope ()Lio/sentry/ISentryLifecycleToken;
+	public fun removeAttribute (Ljava/lang/String;)V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun reportFullyDisplayed ()V
 	public fun setActiveSpan (Lio/sentry/ISpan;)V
+	public fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setFingerprint (Ljava/util/List;)V
 	public fun setLevel (Lio/sentry/SentryLevel;)V
@@ -744,10 +753,14 @@ public final class io/sentry/HubScopesWrapper : io/sentry/IHub {
 	public fun popScope ()V
 	public fun pushIsolationScope ()Lio/sentry/ISentryLifecycleToken;
 	public fun pushScope ()Lio/sentry/ISentryLifecycleToken;
+	public fun removeAttribute (Ljava/lang/String;)V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun reportFullyDisplayed ()V
 	public fun setActiveSpan (Lio/sentry/ISpan;)V
+	public fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setFingerprint (Ljava/util/List;)V
 	public fun setLevel (Lio/sentry/SentryLevel;)V
@@ -867,6 +880,7 @@ public abstract interface class io/sentry/IScope {
 	public abstract fun clone ()Lio/sentry/IScope;
 	public abstract fun endSession ()Lio/sentry/Session;
 	public abstract fun getAttachments ()Ljava/util/List;
+	public abstract fun getAttributes ()Ljava/util/Map;
 	public abstract fun getBreadcrumbs ()Ljava/util/Queue;
 	public abstract fun getClient ()Lio/sentry/ISentryClient;
 	public abstract fun getContexts ()Lio/sentry/protocol/Contexts;
@@ -889,11 +903,15 @@ public abstract interface class io/sentry/IScope {
 	public abstract fun getTransaction ()Lio/sentry/ITransaction;
 	public abstract fun getTransactionName ()Ljava/lang/String;
 	public abstract fun getUser ()Lio/sentry/protocol/User;
+	public abstract fun removeAttribute (Ljava/lang/String;)V
 	public abstract fun removeContexts (Ljava/lang/String;)V
 	public abstract fun removeExtra (Ljava/lang/String;)V
 	public abstract fun removeTag (Ljava/lang/String;)V
 	public abstract fun replaceOptions (Lio/sentry/SentryOptions;)V
 	public abstract fun setActiveSpan (Lio/sentry/ISpan;)V
+	public abstract fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public abstract fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public abstract fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public abstract fun setContexts (Ljava/lang/String;Ljava/lang/Boolean;)V
 	public abstract fun setContexts (Ljava/lang/String;Ljava/lang/Character;)V
 	public abstract fun setContexts (Ljava/lang/String;Ljava/lang/Number;)V
@@ -1005,10 +1023,14 @@ public abstract interface class io/sentry/IScopes {
 	public abstract fun popScope ()V
 	public abstract fun pushIsolationScope ()Lio/sentry/ISentryLifecycleToken;
 	public abstract fun pushScope ()Lio/sentry/ISentryLifecycleToken;
+	public abstract fun removeAttribute (Ljava/lang/String;)V
 	public abstract fun removeExtra (Ljava/lang/String;)V
 	public abstract fun removeTag (Ljava/lang/String;)V
 	public abstract fun reportFullyDisplayed ()V
 	public abstract fun setActiveSpan (Lio/sentry/ISpan;)V
+	public abstract fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public abstract fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public abstract fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public abstract fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public abstract fun setFingerprint (Ljava/util/List;)V
 	public abstract fun setLevel (Lio/sentry/SentryLevel;)V
@@ -1581,10 +1603,14 @@ public final class io/sentry/NoOpHub : io/sentry/IHub {
 	public fun popScope ()V
 	public fun pushIsolationScope ()Lio/sentry/ISentryLifecycleToken;
 	public fun pushScope ()Lio/sentry/ISentryLifecycleToken;
+	public fun removeAttribute (Ljava/lang/String;)V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun reportFullyDisplayed ()V
 	public fun setActiveSpan (Lio/sentry/ISpan;)V
+	public fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setFingerprint (Ljava/util/List;)V
 	public fun setLevel (Lio/sentry/SentryLevel;)V
@@ -1651,6 +1677,7 @@ public final class io/sentry/NoOpScope : io/sentry/IScope {
 	public synthetic fun clone ()Ljava/lang/Object;
 	public fun endSession ()Lio/sentry/Session;
 	public fun getAttachments ()Ljava/util/List;
+	public fun getAttributes ()Ljava/util/Map;
 	public fun getBreadcrumbs ()Ljava/util/Queue;
 	public fun getClient ()Lio/sentry/ISentryClient;
 	public fun getContexts ()Lio/sentry/protocol/Contexts;
@@ -1674,11 +1701,15 @@ public final class io/sentry/NoOpScope : io/sentry/IScope {
 	public fun getTransaction ()Lio/sentry/ITransaction;
 	public fun getTransactionName ()Ljava/lang/String;
 	public fun getUser ()Lio/sentry/protocol/User;
+	public fun removeAttribute (Ljava/lang/String;)V
 	public fun removeContexts (Ljava/lang/String;)V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun replaceOptions (Lio/sentry/SentryOptions;)V
 	public fun setActiveSpan (Lio/sentry/ISpan;)V
+	public fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public fun setContexts (Ljava/lang/String;Ljava/lang/Boolean;)V
 	public fun setContexts (Ljava/lang/String;Ljava/lang/Character;)V
 	public fun setContexts (Ljava/lang/String;Ljava/lang/Number;)V
@@ -1758,10 +1789,14 @@ public final class io/sentry/NoOpScopes : io/sentry/IScopes {
 	public fun popScope ()V
 	public fun pushIsolationScope ()Lio/sentry/ISentryLifecycleToken;
 	public fun pushScope ()Lio/sentry/ISentryLifecycleToken;
+	public fun removeAttribute (Ljava/lang/String;)V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun reportFullyDisplayed ()V
 	public fun setActiveSpan (Lio/sentry/ISpan;)V
+	public fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setFingerprint (Ljava/util/List;)V
 	public fun setLevel (Lio/sentry/SentryLevel;)V
@@ -2327,6 +2362,7 @@ public final class io/sentry/Scope : io/sentry/IScope {
 	public synthetic fun clone ()Ljava/lang/Object;
 	public fun endSession ()Lio/sentry/Session;
 	public fun getAttachments ()Ljava/util/List;
+	public fun getAttributes ()Ljava/util/Map;
 	public fun getBreadcrumbs ()Ljava/util/Queue;
 	public fun getClient ()Lio/sentry/ISentryClient;
 	public fun getContexts ()Lio/sentry/protocol/Contexts;
@@ -2349,11 +2385,15 @@ public final class io/sentry/Scope : io/sentry/IScope {
 	public fun getTransaction ()Lio/sentry/ITransaction;
 	public fun getTransactionName ()Ljava/lang/String;
 	public fun getUser ()Lio/sentry/protocol/User;
+	public fun removeAttribute (Ljava/lang/String;)V
 	public fun removeContexts (Ljava/lang/String;)V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun replaceOptions (Lio/sentry/SentryOptions;)V
 	public fun setActiveSpan (Lio/sentry/ISpan;)V
+	public fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public fun setContexts (Ljava/lang/String;Ljava/lang/Boolean;)V
 	public fun setContexts (Ljava/lang/String;Ljava/lang/Character;)V
 	public fun setContexts (Ljava/lang/String;Ljava/lang/Number;)V
@@ -2484,10 +2524,14 @@ public final class io/sentry/Scopes : io/sentry/IScopes {
 	public fun popScope ()V
 	public fun pushIsolationScope ()Lio/sentry/ISentryLifecycleToken;
 	public fun pushScope ()Lio/sentry/ISentryLifecycleToken;
+	public fun removeAttribute (Ljava/lang/String;)V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun reportFullyDisplayed ()V
 	public fun setActiveSpan (Lio/sentry/ISpan;)V
+	public fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setFingerprint (Ljava/util/List;)V
 	public fun setLevel (Lio/sentry/SentryLevel;)V
@@ -2557,10 +2601,14 @@ public final class io/sentry/ScopesAdapter : io/sentry/IScopes {
 	public fun popScope ()V
 	public fun pushIsolationScope ()Lio/sentry/ISentryLifecycleToken;
 	public fun pushScope ()Lio/sentry/ISentryLifecycleToken;
+	public fun removeAttribute (Ljava/lang/String;)V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun reportFullyDisplayed ()V
 	public fun setActiveSpan (Lio/sentry/ISpan;)V
+	public fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setFingerprint (Ljava/util/List;)V
 	public fun setLevel (Lio/sentry/SentryLevel;)V
@@ -2678,10 +2726,14 @@ public final class io/sentry/Sentry {
 	public static fun popScope ()V
 	public static fun pushIsolationScope ()Lio/sentry/ISentryLifecycleToken;
 	public static fun pushScope ()Lio/sentry/ISentryLifecycleToken;
+	public static fun removeAttribute (Ljava/lang/String;)V
 	public static fun removeExtra (Ljava/lang/String;)V
 	public static fun removeTag (Ljava/lang/String;)V
 	public static fun replay ()Lio/sentry/IReplayApi;
 	public static fun reportFullyDisplayed ()V
+	public static fun setAttribute (Lio/sentry/SentryAttribute;)V
+	public static fun setAttribute (Ljava/lang/String;Ljava/lang/Object;)V
+	public static fun setAttributes (Lio/sentry/SentryAttributes;)V
 	public static fun setCurrentHub (Lio/sentry/IHub;)Lio/sentry/ISentryLifecycleToken;
 	public static fun setCurrentScopes (Lio/sentry/IScopes;)Lio/sentry/ISentryLifecycleToken;
 	public static fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
@@ -2763,6 +2815,8 @@ public final class io/sentry/SentryAppStartProfilingOptions$JsonKeys {
 }
 
 public final class io/sentry/SentryAttribute {
+	public static fun arrayAttribute (Ljava/lang/String;Ljava/util/Collection;)Lio/sentry/SentryAttribute;
+	public static fun arrayAttribute (Ljava/lang/String;[Ljava/lang/Object;)Lio/sentry/SentryAttribute;
 	public static fun booleanAttribute (Ljava/lang/String;Ljava/lang/Boolean;)Lio/sentry/SentryAttribute;
 	public static fun doubleAttribute (Ljava/lang/String;Ljava/lang/Double;)Lio/sentry/SentryAttribute;
 	public fun getName ()Ljava/lang/String;
@@ -2774,11 +2828,13 @@ public final class io/sentry/SentryAttribute {
 }
 
 public final class io/sentry/SentryAttributeType : java/lang/Enum {
+	public static final field ARRAY Lio/sentry/SentryAttributeType;
 	public static final field BOOLEAN Lio/sentry/SentryAttributeType;
 	public static final field DOUBLE Lio/sentry/SentryAttributeType;
 	public static final field INTEGER Lio/sentry/SentryAttributeType;
 	public static final field STRING Lio/sentry/SentryAttributeType;
 	public fun apiName ()Ljava/lang/String;
+	public static fun inferFrom (Ljava/lang/Object;)Lio/sentry/SentryAttributeType;
 	public static fun valueOf (Ljava/lang/String;)Lio/sentry/SentryAttributeType;
 	public static fun values ()[Lio/sentry/SentryAttributeType;
 }
@@ -3288,6 +3344,7 @@ public final class io/sentry/SentryLogEvent$JsonKeys {
 public final class io/sentry/SentryLogEventAttributeValue : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
 	public fun <init> (Lio/sentry/SentryAttributeType;Ljava/lang/Object;)V
 	public fun <init> (Ljava/lang/String;Ljava/lang/Object;)V
+	public static fun fromAttribute (Lio/sentry/SentryAttribute;)Lio/sentry/SentryLogEventAttributeValue;
 	public fun getType ()Ljava/lang/String;
 	public fun getUnknown ()Ljava/util/Map;
 	public fun getValue ()Ljava/lang/Object;
diff --git a/sentry/src/main/java/io/sentry/CombinedScopeView.java b/sentry/src/main/java/io/sentry/CombinedScopeView.java
index fc90e6255bd..0c61bdf9126 100644
--- a/sentry/src/main/java/io/sentry/CombinedScopeView.java
+++ b/sentry/src/main/java/io/sentry/CombinedScopeView.java
@@ -241,6 +241,35 @@ public void removeTag(@Nullable String key) {
     getDefaultWriteScope().removeTag(key);
   }
 
+  @Override
+  public @NotNull Map<String, SentryAttribute> getAttributes() {
+    final @NotNull Map<String, SentryAttribute> allAttributes = new ConcurrentHashMap<>();
+    allAttributes.putAll(globalScope.getAttributes());
+    allAttributes.putAll(isolationScope.getAttributes());
+    allAttributes.putAll(scope.getAttributes());
+    return allAttributes;
+  }
+
+  @Override
+  public void setAttribute(@Nullable String key, @Nullable Object value) {
+    getDefaultWriteScope().setAttribute(key, value);
+  }
+
+  @Override
+  public void setAttribute(@Nullable SentryAttribute attribute) {
+    getDefaultWriteScope().setAttribute(attribute);
+  }
+
+  @Override
+  public void setAttributes(@Nullable SentryAttributes attributes) {
+    getDefaultWriteScope().setAttributes(attributes);
+  }
+
+  @Override
+  public void removeAttribute(@Nullable String key) {
+    getDefaultWriteScope().removeAttribute(key);
+  }
+
   @Override
   public @NotNull Map<String, Object> getExtras() {
     final @NotNull Map<String, Object> allTags = new ConcurrentHashMap<>();
diff --git a/sentry/src/main/java/io/sentry/HubAdapter.java b/sentry/src/main/java/io/sentry/HubAdapter.java
index 5715d061144..cf90eb1fe65 100644
--- a/sentry/src/main/java/io/sentry/HubAdapter.java
+++ b/sentry/src/main/java/io/sentry/HubAdapter.java
@@ -395,6 +395,26 @@ public void reportFullyDisplayed() {
     return Sentry.getCurrentScopes().metrics();
   }
 
+  @Override
+  public void setAttribute(final @Nullable String key, final @Nullable Object value) {
+    Sentry.setAttribute(key, value);
+  }
+
+  @Override
+  public void setAttribute(final @Nullable SentryAttribute attribute) {
+    Sentry.setAttribute(attribute);
+  }
+
+  @Override
+  public void setAttributes(final @Nullable SentryAttributes attributes) {
+    Sentry.setAttributes(attributes);
+  }
+
+  @Override
+  public void removeAttribute(final @Nullable String key) {
+    Sentry.removeAttribute(key);
+  }
+
   @Override
   public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result) {
     Sentry.addFeatureFlag(flag, result);
diff --git a/sentry/src/main/java/io/sentry/HubScopesWrapper.java b/sentry/src/main/java/io/sentry/HubScopesWrapper.java
index c04aad9ed8c..66a34b4dc36 100644
--- a/sentry/src/main/java/io/sentry/HubScopesWrapper.java
+++ b/sentry/src/main/java/io/sentry/HubScopesWrapper.java
@@ -380,6 +380,26 @@ public void reportFullyDisplayed() {
     return scopes.metrics();
   }
 
+  @Override
+  public void setAttribute(final @Nullable String key, final @Nullable Object value) {
+    scopes.setAttribute(key, value);
+  }
+
+  @Override
+  public void setAttribute(final @Nullable SentryAttribute attribute) {
+    scopes.setAttribute(attribute);
+  }
+
+  @Override
+  public void setAttributes(final @Nullable SentryAttributes attributes) {
+    scopes.setAttributes(attributes);
+  }
+
+  @Override
+  public void removeAttribute(final @Nullable String key) {
+    scopes.removeAttribute(key);
+  }
+
   @Override
   public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result) {
     scopes.addFeatureFlag(flag, result);
diff --git a/sentry/src/main/java/io/sentry/IScope.java b/sentry/src/main/java/io/sentry/IScope.java
index f41ea1cbbe1..ccab8dbdeb3 100644
--- a/sentry/src/main/java/io/sentry/IScope.java
+++ b/sentry/src/main/java/io/sentry/IScope.java
@@ -425,6 +425,44 @@ void setSpanContext(
   @ApiStatus.Internal
   void replaceOptions(final @NotNull SentryOptions options);
 
+  /**
+   * Sets an attribute on the Scope.
+   *
+   * @param key the key
+   * @param value the value
+   */
+  void setAttribute(final @Nullable String key, final @Nullable Object value);
+
+  /**
+   * Sets an attribute on the Scope.
+   *
+   * @param attribute the attribute
+   */
+  void setAttribute(final @Nullable SentryAttribute attribute);
+
+  /**
+   * Sets multiple attributes on the Scope.
+   *
+   * @param attributes the attributes
+   */
+  void setAttributes(final @Nullable SentryAttributes attributes);
+
+  /**
+   * Removes an attribute from the Scope.
+   *
+   * @param key the key
+   */
+  void removeAttribute(final @Nullable String key);
+
+  /**
+   * Returns the Scope's attributes
+   *
+   * @return the attributes map
+   */
+  @ApiStatus.Internal
+  @NotNull
+  Map<String, SentryAttribute> getAttributes();
+
   void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result);
 
   @ApiStatus.Internal
diff --git a/sentry/src/main/java/io/sentry/IScopes.java b/sentry/src/main/java/io/sentry/IScopes.java
index 0a7c86fa8e6..b1b437f72e5 100644
--- a/sentry/src/main/java/io/sentry/IScopes.java
+++ b/sentry/src/main/java/io/sentry/IScopes.java
@@ -748,5 +748,34 @@ default boolean isNoOp() {
   @NotNull
   IMetricsApi metrics();
 
+  /**
+   * Sets an attribute.
+   *
+   * @param key the key
+   * @param value the value
+   */
+  void setAttribute(final @Nullable String key, final @Nullable Object value);
+
+  /**
+   * Sets an attribute.
+   *
+   * @param attribute the attribute
+   */
+  void setAttribute(final @Nullable SentryAttribute attribute);
+
+  /**
+   * Sets multiple attributes.
+   *
+   * @param attributes the attributes
+   */
+  void setAttributes(final @Nullable SentryAttributes attributes);
+
+  /**
+   * Removes an attribute.
+   *
+   * @param key the key
+   */
+  void removeAttribute(final @Nullable String key);
+
   void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result);
 }
diff --git a/sentry/src/main/java/io/sentry/NoOpHub.java b/sentry/src/main/java/io/sentry/NoOpHub.java
index 2885d8017d1..4a02be1bd40 100644
--- a/sentry/src/main/java/io/sentry/NoOpHub.java
+++ b/sentry/src/main/java/io/sentry/NoOpHub.java
@@ -338,6 +338,18 @@ public boolean isNoOp() {
     return NoOpMetricsApi.getInstance();
   }
 
+  @Override
+  public void setAttribute(final @Nullable String key, final @Nullable Object value) {}
+
+  @Override
+  public void setAttribute(final @Nullable SentryAttribute attribute) {}
+
+  @Override
+  public void setAttributes(final @Nullable SentryAttributes attributes) {}
+
+  @Override
+  public void removeAttribute(final @Nullable String key) {}
+
   @Override
   public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result) {}
 }
diff --git a/sentry/src/main/java/io/sentry/NoOpScope.java b/sentry/src/main/java/io/sentry/NoOpScope.java
index c04c5af87bd..7693ab81deb 100644
--- a/sentry/src/main/java/io/sentry/NoOpScope.java
+++ b/sentry/src/main/java/io/sentry/NoOpScope.java
@@ -300,6 +300,24 @@ public void setSpanContext(
   @Override
   public void replaceOptions(@NotNull SentryOptions options) {}
 
+  @Override
+  public void setAttribute(@Nullable String key, @Nullable Object value) {}
+
+  @Override
+  public void setAttribute(@Nullable SentryAttribute attribute) {}
+
+  @Override
+  public void setAttributes(@Nullable SentryAttributes attributes) {}
+
+  @Override
+  public void removeAttribute(@Nullable String key) {}
+
+  @ApiStatus.Internal
+  @Override
+  public @NotNull Map<String, SentryAttribute> getAttributes() {
+    return new HashMap<>();
+  }
+
   @Override
   public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result) {}
 
diff --git a/sentry/src/main/java/io/sentry/NoOpScopes.java b/sentry/src/main/java/io/sentry/NoOpScopes.java
index 5abb20226ac..1ae357d502e 100644
--- a/sentry/src/main/java/io/sentry/NoOpScopes.java
+++ b/sentry/src/main/java/io/sentry/NoOpScopes.java
@@ -336,6 +336,18 @@ public boolean isNoOp() {
     return NoOpMetricsApi.getInstance();
   }
 
+  @Override
+  public void setAttribute(final @Nullable String key, final @Nullable Object value) {}
+
+  @Override
+  public void setAttribute(final @Nullable SentryAttribute attribute) {}
+
+  @Override
+  public void setAttributes(final @Nullable SentryAttributes attributes) {}
+
+  @Override
+  public void removeAttribute(final @Nullable String key) {}
+
   @Override
   public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result) {}
 }
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index 5fc82a648d3..1aab545b80c 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -65,6 +65,9 @@ public final class Scope implements IScope {
   /** Scope's tags */
   private @NotNull Map<String, @NotNull String> tags = new ConcurrentHashMap<>();
 
+  /** Scope's attributes */
+  private @NotNull Map<String, @NotNull SentryAttribute> attributes = new ConcurrentHashMap<>();
+
   /** Scope's extras */
   private @NotNull Map<String, @NotNull Object> extra = new ConcurrentHashMap<>();
 
@@ -164,6 +167,18 @@ private Scope(final @NotNull Scope scope) {
 
     this.tags = tagsClone;
 
+    final Map<String, SentryAttribute> attributesRef = scope.attributes;
+
+    final Map<String, @NotNull SentryAttribute> attributesClone = new ConcurrentHashMap<>();
+
+    for (Map.Entry<String, SentryAttribute> item : attributesRef.entrySet()) {
+      if (item != null) {
+        attributesClone.put(item.getKey(), item.getValue()); // shallow copy
+      }
+    }
+
+    this.attributes = attributesClone;
+
     final Map<String, Object> extraRef = scope.extra;
 
     Map<String, @NotNull Object> extraClone = new ConcurrentHashMap<>();
@@ -554,6 +569,7 @@ public void clear() {
     fingerprint.clear();
     clearBreadcrumbs();
     tags.clear();
+    attributes.clear();
     extra.clear();
     eventProcessors.clear();
     clearTransaction();
@@ -613,6 +629,60 @@ public void removeTag(final @Nullable String key) {
     }
   }
 
+  /**
+   * Returns the Scope's attributes
+   *
+   * @return the attributes map
+   */
+  @ApiStatus.Internal
+  @SuppressWarnings("NullAway") // attributes are never null
+  @Override
+  public @NotNull Map<String, SentryAttribute> getAttributes() {
+    return CollectionUtils.newConcurrentHashMap(attributes);
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void setAttribute(final @Nullable String key, final @Nullable Object value) {
+    if (key == null) {
+      return;
+    }
+    if (value == null) {
+      removeAttribute(key);
+    } else {
+      this.attributes.put(key, SentryAttribute.named(key, value));
+    }
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void setAttribute(final @Nullable SentryAttribute attribute) {
+    if (attribute == null) {
+      return;
+    }
+    this.attributes.put(attribute.getName(), attribute);
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void setAttributes(final @Nullable SentryAttributes attributes) {
+    if (attributes == null) {
+      return;
+    }
+    for (SentryAttribute attribute : attributes.getAttributes().values()) {
+      this.attributes.put(attribute.getName(), attribute);
+    }
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public void removeAttribute(final @Nullable String key) {
+    if (key == null) {
+      return;
+    }
+    this.attributes.remove(key);
+  }
+
   /**
    * Returns the Scope's extra map
    *
diff --git a/sentry/src/main/java/io/sentry/Scopes.java b/sentry/src/main/java/io/sentry/Scopes.java
index ee3d55f2291..e155979e064 100644
--- a/sentry/src/main/java/io/sentry/Scopes.java
+++ b/sentry/src/main/java/io/sentry/Scopes.java
@@ -1244,6 +1244,56 @@ public void reportFullyDisplayed() {
     return metrics;
   }
 
+  @Override
+  public void setAttribute(final @Nullable String key, final @Nullable Object value) {
+    if (!isEnabled()) {
+      getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.WARNING, "Instance is disabled and this 'setAttribute' call is a no-op.");
+    } else {
+      getCombinedScopeView().setAttribute(key, value);
+    }
+  }
+
+  @Override
+  public void setAttribute(final @Nullable SentryAttribute attribute) {
+    if (!isEnabled()) {
+      getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.WARNING, "Instance is disabled and this 'setAttribute' call is a no-op.");
+    } else {
+      getCombinedScopeView().setAttribute(attribute);
+    }
+  }
+
+  @Override
+  public void setAttributes(final @Nullable SentryAttributes attributes) {
+    if (!isEnabled()) {
+      getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.WARNING,
+              "Instance is disabled and this 'setAttributes' call is a no-op.");
+    } else {
+      getCombinedScopeView().setAttributes(attributes);
+    }
+  }
+
+  @Override
+  public void removeAttribute(final @Nullable String key) {
+    if (!isEnabled()) {
+      getOptions()
+          .getLogger()
+          .log(
+              SentryLevel.WARNING,
+              "Instance is disabled and this 'removeAttribute' call is a no-op.");
+    } else {
+      getCombinedScopeView().removeAttribute(key);
+    }
+  }
+
   @Override
   public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result) {
     combinedScope.addFeatureFlag(flag, result);
diff --git a/sentry/src/main/java/io/sentry/ScopesAdapter.java b/sentry/src/main/java/io/sentry/ScopesAdapter.java
index ba7e74d23bb..b66b681a332 100644
--- a/sentry/src/main/java/io/sentry/ScopesAdapter.java
+++ b/sentry/src/main/java/io/sentry/ScopesAdapter.java
@@ -392,6 +392,26 @@ public void reportFullyDisplayed() {
     return Sentry.getCurrentScopes().metrics();
   }
 
+  @Override
+  public void setAttribute(final @Nullable String key, final @Nullable Object value) {
+    Sentry.setAttribute(key, value);
+  }
+
+  @Override
+  public void setAttribute(final @Nullable SentryAttribute attribute) {
+    Sentry.setAttribute(attribute);
+  }
+
+  @Override
+  public void setAttributes(final @Nullable SentryAttributes attributes) {
+    Sentry.setAttributes(attributes);
+  }
+
+  @Override
+  public void removeAttribute(final @Nullable String key) {
+    Sentry.removeAttribute(key);
+  }
+
   @Override
   public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result) {
     Sentry.addFeatureFlag(flag, result);
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index 8acc051f522..63caf829fc9 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -1368,6 +1368,43 @@ public static void showUserFeedbackDialog(
     options.getFeedbackOptions().getDialogHandler().showDialog(associatedEventId, configurator);
   }
 
+  /**
+   * Sets an attribute on the scope.
+   *
+   * @param key the key
+   * @param value the value
+   */
+  public static void setAttribute(final @Nullable String key, final @Nullable Object value) {
+    getCurrentScopes().setAttribute(key, value);
+  }
+
+  /**
+   * Sets an attribute on the scope.
+   *
+   * @param attribute the attribute
+   */
+  public static void setAttribute(final @Nullable SentryAttribute attribute) {
+    getCurrentScopes().setAttribute(attribute);
+  }
+
+  /**
+   * Sets multiple attributes on the scope.
+   *
+   * @param attributes the attributes
+   */
+  public static void setAttributes(final @Nullable SentryAttributes attributes) {
+    getCurrentScopes().setAttributes(attributes);
+  }
+
+  /**
+   * Removes an attribute from the scope.
+   *
+   * @param key the key
+   */
+  public static void removeAttribute(final @Nullable String key) {
+    getCurrentScopes().removeAttribute(key);
+  }
+
   public static void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result) {
     getCurrentScopes().addFeatureFlag(flag, result);
   }
diff --git a/sentry/src/main/java/io/sentry/SentryAttribute.java b/sentry/src/main/java/io/sentry/SentryAttribute.java
index 4bcef14ee8c..213ef53d91e 100644
--- a/sentry/src/main/java/io/sentry/SentryAttribute.java
+++ b/sentry/src/main/java/io/sentry/SentryAttribute.java
@@ -1,5 +1,6 @@
 package io.sentry;
 
+import java.util.Collection;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -54,4 +55,14 @@ private SentryAttribute(
       final @NotNull String name, final @Nullable String value) {
     return new SentryAttribute(name, SentryAttributeType.STRING, value);
   }
+
+  public static @NotNull SentryAttribute arrayAttribute(
+      final @NotNull String name, final @Nullable Collection<?> value) {
+    return new SentryAttribute(name, SentryAttributeType.ARRAY, value);
+  }
+
+  public static @NotNull SentryAttribute arrayAttribute(
+      final @NotNull String name, final @Nullable Object[] value) {
+    return new SentryAttribute(name, SentryAttributeType.ARRAY, value);
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/SentryAttributeType.java b/sentry/src/main/java/io/sentry/SentryAttributeType.java
index a47d7e71f0e..b6648179631 100644
--- a/sentry/src/main/java/io/sentry/SentryAttributeType.java
+++ b/sentry/src/main/java/io/sentry/SentryAttributeType.java
@@ -1,15 +1,43 @@
 package io.sentry;
 
+import java.math.BigInteger;
+import java.util.Collection;
 import java.util.Locale;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 public enum SentryAttributeType {
   STRING,
   BOOLEAN,
   INTEGER,
-  DOUBLE;
+  DOUBLE,
+  ARRAY;
 
   public @NotNull String apiName() {
     return name().toLowerCase(Locale.ROOT);
   }
+
+  public static @NotNull SentryAttributeType inferFrom(final @Nullable Object value) {
+    if (value instanceof Boolean) {
+      return BOOLEAN;
+    }
+    if (value instanceof Integer
+        || value instanceof Long
+        || value instanceof Short
+        || value instanceof Byte
+        || value instanceof BigInteger
+        || value instanceof AtomicInteger
+        || value instanceof AtomicLong) {
+      return INTEGER;
+    }
+    if (value instanceof Number) {
+      return DOUBLE;
+    }
+    if (value instanceof Collection || (value != null && value.getClass().isArray())) {
+      return ARRAY;
+    }
+    return STRING;
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/SentryLogEventAttributeValue.java b/sentry/src/main/java/io/sentry/SentryLogEventAttributeValue.java
index 1fd7c8c4528..6f6542927f9 100644
--- a/sentry/src/main/java/io/sentry/SentryLogEventAttributeValue.java
+++ b/sentry/src/main/java/io/sentry/SentryLogEventAttributeValue.java
@@ -27,6 +27,21 @@ public SentryLogEventAttributeValue(
     this(type.apiName(), value);
   }
 
+  /**
+   * Creates a {@link SentryLogEventAttributeValue} from a {@link SentryAttribute}, inferring the
+   * type if not explicitly set.
+   *
+   * @param attribute the attribute
+   * @return the attribute value
+   */
+  public static @NotNull SentryLogEventAttributeValue fromAttribute(
+      final @NotNull SentryAttribute attribute) {
+    final @Nullable Object value = attribute.getValue();
+    final @NotNull SentryAttributeType type =
+        attribute.getType() == null ? SentryAttributeType.inferFrom(value) : attribute.getType();
+    return new SentryLogEventAttributeValue(type, value);
+  }
+
   public @NotNull String getType() {
     return type;
   }
diff --git a/sentry/src/main/java/io/sentry/logger/LoggerApi.java b/sentry/src/main/java/io/sentry/logger/LoggerApi.java
index 37a485df315..c203dcbfb8f 100644
--- a/sentry/src/main/java/io/sentry/logger/LoggerApi.java
+++ b/sentry/src/main/java/io/sentry/logger/LoggerApi.java
@@ -21,6 +21,7 @@
 import io.sentry.util.Platform;
 import io.sentry.util.TracingUtils;
 import java.util.HashMap;
+import java.util.Map;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -163,6 +164,14 @@ private void captureLog(
       final @NotNull String message,
       final @Nullable Object... args) {
     final @NotNull HashMap<String, SentryLogEventAttributeValue> attributes = new HashMap<>();
+
+    final @NotNull Map<String, SentryAttribute> scopeAttributes =
+        scopes.getCombinedScopeView().getAttributes();
+    for (SentryAttribute scopeAttribute : scopeAttributes.values()) {
+      attributes.put(
+          scopeAttribute.getName(), SentryLogEventAttributeValue.fromAttribute(scopeAttribute));
+    }
+
     final @NotNull String origin = params.getOrigin();
     if (!"manual".equalsIgnoreCase(origin)) {
       attributes.put(
@@ -173,17 +182,14 @@ private void captureLog(
 
     if (incomingAttributes != null) {
       for (SentryAttribute attribute : incomingAttributes.getAttributes().values()) {
-        final @Nullable Object value = attribute.getValue();
-        final @NotNull SentryAttributeType type =
-            attribute.getType() == null ? getType(value) : attribute.getType();
-        attributes.put(attribute.getName(), new SentryLogEventAttributeValue(type, value));
+        attributes.put(attribute.getName(), SentryLogEventAttributeValue.fromAttribute(attribute));
       }
     }
 
     if (args != null) {
       int i = 0;
       for (Object arg : args) {
-        final @NotNull SentryAttributeType type = getType(arg);
+        final @NotNull SentryAttributeType type = SentryAttributeType.inferFrom(arg);
         attributes.put(
             "sentry.message.parameter." + i, new SentryLogEventAttributeValue(type, arg));
         i++;
@@ -292,17 +298,4 @@ private void setUser(final @NotNull HashMap<String, SentryLogEventAttributeValue
       }
     }
   }
-
-  private @NotNull SentryAttributeType getType(final @Nullable Object arg) {
-    if (arg instanceof Boolean) {
-      return SentryAttributeType.BOOLEAN;
-    }
-    if (arg instanceof Integer) {
-      return SentryAttributeType.INTEGER;
-    }
-    if (arg instanceof Number) {
-      return SentryAttributeType.DOUBLE;
-    }
-    return SentryAttributeType.STRING;
-  }
 }
diff --git a/sentry/src/main/java/io/sentry/metrics/MetricsApi.java b/sentry/src/main/java/io/sentry/metrics/MetricsApi.java
index fc16d60e0ec..cebcad9735c 100644
--- a/sentry/src/main/java/io/sentry/metrics/MetricsApi.java
+++ b/sentry/src/main/java/io/sentry/metrics/MetricsApi.java
@@ -20,6 +20,7 @@
 import io.sentry.util.Platform;
 import io.sentry.util.TracingUtils;
 import java.util.HashMap;
+import java.util.Map;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -167,6 +168,14 @@ private void captureMetrics(
   private @NotNull HashMap<String, SentryLogEventAttributeValue> createAttributes(
       final @NotNull SentryMetricsParameters params) {
     final @NotNull HashMap<String, SentryLogEventAttributeValue> attributes = new HashMap<>();
+
+    final @NotNull Map<String, SentryAttribute> scopeAttributes =
+        scopes.getCombinedScopeView().getAttributes();
+    for (SentryAttribute scopeAttribute : scopeAttributes.values()) {
+      attributes.put(
+          scopeAttribute.getName(), SentryLogEventAttributeValue.fromAttribute(scopeAttribute));
+    }
+
     final @NotNull String origin = params.getOrigin();
     if (!"manual".equalsIgnoreCase(origin)) {
       attributes.put(
@@ -177,10 +186,7 @@ private void captureMetrics(
 
     if (incomingAttributes != null) {
       for (SentryAttribute attribute : incomingAttributes.getAttributes().values()) {
-        final @Nullable Object value = attribute.getValue();
-        final @NotNull SentryAttributeType type =
-            attribute.getType() == null ? getType(value) : attribute.getType();
-        attributes.put(attribute.getName(), new SentryLogEventAttributeValue(type, value));
+        attributes.put(attribute.getName(), SentryLogEventAttributeValue.fromAttribute(attribute));
       }
     }
 
@@ -279,17 +285,4 @@ private void setUser(final @NotNull HashMap<String, SentryLogEventAttributeValue
       }
     }
   }
-
-  private @NotNull SentryAttributeType getType(final @Nullable Object arg) {
-    if (arg instanceof Boolean) {
-      return SentryAttributeType.BOOLEAN;
-    }
-    if (arg instanceof Integer) {
-      return SentryAttributeType.INTEGER;
-    }
-    if (arg instanceof Number) {
-      return SentryAttributeType.DOUBLE;
-    }
-    return SentryAttributeType.STRING;
-  }
 }
diff --git a/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt b/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt
index baeb076463f..d768d6d32d6 100644
--- a/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt
+++ b/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt
@@ -1242,6 +1242,73 @@ class CombinedScopeViewTest {
     kotlin.test.assertTrue(scope.contexts.isEmpty)
   }
 
+  @Test
+  fun `attributes are combined from all scopes`() {
+    val combined = fixture.getSut()
+
+    fixture.scope.setAttribute("scopeAttr", "scopeValue")
+    fixture.isolationScope.setAttribute("isolationAttr", "isolationValue")
+    fixture.globalScope.setAttribute("globalAttr", "globalValue")
+
+    val attrs = combined.attributes
+    assertEquals("scopeValue", attrs["scopeAttr"]?.value)
+    assertEquals("isolationValue", attrs["isolationAttr"]?.value)
+    assertEquals("globalValue", attrs["globalAttr"]?.value)
+  }
+
+  @Test
+  fun `setAttribute writes to default scope`() {
+    val combined = fixture.getSut()
+    combined.setAttribute("anAttr", "aValue")
+
+    assertEquals(ScopeType.ISOLATION, fixture.options.defaultScopeType)
+    assertNull(fixture.scope.attributes["anAttr"])
+    assertEquals("aValue", fixture.isolationScope.attributes["anAttr"]?.value)
+    assertNull(fixture.globalScope.attributes["anAttr"])
+  }
+
+  @Test
+  fun `prefer current scope value for attributes with same key`() {
+    val combined = fixture.getSut()
+
+    fixture.scope.setAttribute("anAttr", "scopeValue")
+    fixture.isolationScope.setAttribute("anAttr", "isolationValue")
+    fixture.globalScope.setAttribute("anAttr", "globalValue")
+
+    assertEquals("scopeValue", combined.attributes["anAttr"]?.value)
+  }
+
+  @Test
+  fun `uses isolation scope value for attributes with same key if scope does not have it`() {
+    val combined = fixture.getSut()
+
+    fixture.isolationScope.setAttribute("anAttr", "isolationValue")
+    fixture.globalScope.setAttribute("anAttr", "globalValue")
+
+    assertEquals("isolationValue", combined.attributes["anAttr"]?.value)
+  }
+
+  @Test
+  fun `uses global scope value for attributes with same key if scope and isolation scope do not have it`() {
+    val combined = fixture.getSut()
+
+    fixture.globalScope.setAttribute("anAttr", "globalValue")
+
+    assertEquals("globalValue", combined.attributes["anAttr"]?.value)
+  }
+
+  @Test
+  fun `removeAttribute removes from default scope`() {
+    val combined = fixture.getSut()
+
+    fixture.isolationScope.setAttribute("anAttr", "isolationValue")
+
+    combined.removeAttribute("anAttr")
+
+    assertEquals(ScopeType.ISOLATION, fixture.options.defaultScopeType)
+    assertTrue(fixture.isolationScope.attributes.isEmpty())
+  }
+
   private fun createTransaction(name: String, scopes: Scopes? = null): ITransaction {
     val scopesToUse = scopes ?: fixture.scopes
     return SentryTracer(TransactionContext(name, "op", TracesSamplingDecision(true)), scopesToUse)
diff --git a/sentry/src/test/java/io/sentry/ScopeTest.kt b/sentry/src/test/java/io/sentry/ScopeTest.kt
index bccc7d602ab..7093473a60b 100644
--- a/sentry/src/test/java/io/sentry/ScopeTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopeTest.kt
@@ -291,6 +291,7 @@ class ScopeTest {
     scope.setTag("some", "tag")
     scope.screen = "MainActivity"
     scope.setExtra("some", "extra")
+    scope.setAttribute("some", "attribute")
     scope.addEventProcessor(eventProcessor())
     scope.addAttachment(Attachment("path"))
 
@@ -304,6 +305,7 @@ class ScopeTest {
     assertEquals(0, scope.fingerprint.size)
     assertEquals(0, scope.breadcrumbs.size)
     assertEquals(0, scope.tags.size)
+    assertEquals(0, scope.attributes.size)
     assertEquals(0, scope.extras.size)
     assertEquals(0, scope.eventProcessors.size)
     assertEquals(0, scope.attachments.size)
@@ -1153,6 +1155,108 @@ class ScopeTest {
     assertEquals(0, flags.values.size)
   }
 
+  @Test
+  fun `setAttribute stores attribute on scope`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttribute("key1", "value1")
+    val attrs = scope.attributes
+    assertEquals(1, attrs.size)
+    assertEquals("value1", attrs["key1"]?.value)
+  }
+
+  @Test
+  fun `setAttribute with SentryAttribute stores attribute on scope`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttribute(SentryAttribute.stringAttribute("key1", "value1"))
+    val attrs = scope.attributes
+    assertEquals(1, attrs.size)
+    assertEquals("value1", attrs["key1"]?.value)
+    assertEquals(SentryAttributeType.STRING, attrs["key1"]?.type)
+  }
+
+  @Test
+  fun `setAttributes stores multiple attributes on scope`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttributes(
+      SentryAttributes.of(
+        SentryAttribute.stringAttribute("key1", "value1"),
+        SentryAttribute.integerAttribute("key2", 42),
+      )
+    )
+    val attrs = scope.attributes
+    assertEquals(2, attrs.size)
+    assertEquals("value1", attrs["key1"]?.value)
+    assertEquals(42, attrs["key2"]?.value)
+  }
+
+  @Test
+  fun `setAttribute with same key overwrites`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttribute("key1", "value1")
+    scope.setAttribute("key1", "value2")
+    val attrs = scope.attributes
+    assertEquals(1, attrs.size)
+    assertEquals("value2", attrs["key1"]?.value)
+  }
+
+  @Test
+  fun `setAttribute with null key is no-op`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttribute(null, "value1")
+    assertEquals(0, scope.attributes.size)
+  }
+
+  @Test
+  fun `setAttribute with null value removes attribute`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttribute("key1", "value1")
+    assertEquals(1, scope.attributes.size)
+    scope.setAttribute("key1", null)
+    assertEquals(0, scope.attributes.size)
+  }
+
+  @Test
+  fun `removeAttribute removes attribute from scope`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttribute("key1", "value1")
+    scope.setAttribute("key2", "value2")
+    scope.removeAttribute("key1")
+    val attrs = scope.attributes
+    assertEquals(1, attrs.size)
+    assertNull(attrs["key1"])
+    assertEquals("value2", attrs["key2"]?.value)
+  }
+
+  @Test
+  fun `removeAttribute with null key is no-op`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttribute("key1", "value1")
+    scope.removeAttribute(null)
+    assertEquals(1, scope.attributes.size)
+  }
+
+  @Test
+  fun `scope clone copies attributes independently`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttribute("key1", "value1")
+
+    val clone = scope.clone()
+    clone.setAttribute("key2", "value2")
+
+    assertEquals(1, scope.attributes.size)
+    assertEquals(2, clone.attributes.size)
+  }
+
+  @Test
+  fun `clear removes attributes`() {
+    val scope = Scope(SentryOptions())
+    scope.setAttribute("key1", "value1")
+    assertEquals(1, scope.attributes.size)
+
+    scope.clear()
+    assertEquals(0, scope.attributes.size)
+  }
+
   private fun eventProcessor(): EventProcessor =
     object : EventProcessor {
       override fun process(event: SentryEvent, hint: Hint): SentryEvent? = event
diff --git a/sentry/src/test/java/io/sentry/ScopesTest.kt b/sentry/src/test/java/io/sentry/ScopesTest.kt
index 73a14b38e71..a4c2c76845e 100644
--- a/sentry/src/test/java/io/sentry/ScopesTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopesTest.kt
@@ -1290,6 +1290,50 @@ class ScopesTest {
 
   // endregion
 
+  // region setAttribute tests
+  @Test
+  fun `when setAttribute is called on disabled client, do nothing`() {
+    val scopes = generateScopes()
+    var scope: IScope? = null
+    scopes.configureScope { scope = it }
+    scopes.close()
+
+    scopes.setAttribute("test", "test")
+    assertEquals(0, scope?.attributes?.count())
+  }
+
+  @Test
+  fun `when setAttribute with SentryAttribute is called on disabled client, do nothing`() {
+    val scopes = generateScopes()
+    var scope: IScope? = null
+    scopes.configureScope { scope = it }
+    scopes.close()
+
+    scopes.setAttribute(SentryAttribute.stringAttribute("test", "test"))
+    assertEquals(0, scope?.attributes?.count())
+  }
+
+  @Test
+  fun `when setAttributes is called on disabled client, do nothing`() {
+    val scopes = generateScopes()
+    var scope: IScope? = null
+    scopes.configureScope { scope = it }
+    scopes.close()
+
+    scopes.setAttributes(SentryAttributes.of(SentryAttribute.stringAttribute("test", "test")))
+    assertEquals(0, scope?.attributes?.count())
+  }
+
+  @Test
+  fun `when removeAttribute is called on disabled client, do nothing`() {
+    val scopes = generateScopes()
+    scopes.close()
+
+    scopes.removeAttribute("test")
+  }
+
+  // endregion
+
   // region captureEnvelope tests
   @Test
   fun `when captureEnvelope is called and envelope is null, throws IllegalArgumentException`() {
@@ -2726,10 +2770,12 @@ class ScopesTest {
             SentryAttribute.booleanAttribute("boolattr", true),
             SentryAttribute.integerAttribute("intattr", 17),
             SentryAttribute.doubleAttribute("doubleattr", 3.8),
+            SentryAttribute.arrayAttribute("arrayattr", listOf("a", "b")),
             SentryAttribute.named("namedstrattr", "namedstrval"),
             SentryAttribute.named("namedboolattr", false),
             SentryAttribute.named("namedintattr", 18),
             SentryAttribute.named("nameddoubleattr", 4.9),
+            SentryAttribute.named("namedarrayattr", listOf("x", "y")),
           )
         ),
         "log message",
@@ -2758,6 +2804,10 @@ class ScopesTest {
           assertEquals(3.8, doubleattr.value)
           assertEquals("double", doubleattr.type)
 
+          val arrayattr = it.attributes?.get("arrayattr")!!
+          assertEquals(listOf("a", "b"), arrayattr.value)
+          assertEquals("array", arrayattr.type)
+
           val namedstrattr = it.attributes?.get("namedstrattr")!!
           assertEquals("namedstrval", namedstrattr.value)
           assertEquals("string", namedstrattr.type)
@@ -2773,6 +2823,10 @@ class ScopesTest {
           val nameddoubleattr = it.attributes?.get("nameddoubleattr")!!
           assertEquals(4.9, nameddoubleattr.value)
           assertEquals("double", nameddoubleattr.type)
+
+          val namedarrayattr = it.attributes?.get("namedarrayattr")!!
+          assertEquals(listOf("x", "y"), namedarrayattr.value)
+          assertEquals("array", namedarrayattr.type)
         },
         anyOrNull(),
       )
@@ -3460,10 +3514,12 @@ class ScopesTest {
             SentryAttribute.booleanAttribute("boolattr", true),
             SentryAttribute.integerAttribute("intattr", 17),
             SentryAttribute.doubleAttribute("doubleattr", 3.8),
+            SentryAttribute.arrayAttribute("arrayattr", listOf("a", "b")),
             SentryAttribute.named("namedstrattr", "namedstrval"),
             SentryAttribute.named("namedboolattr", false),
             SentryAttribute.named("namedintattr", 18),
             SentryAttribute.named("nameddoubleattr", 4.9),
+            SentryAttribute.named("namedarrayattr", listOf("x", "y")),
           )
         ),
       )
@@ -3492,6 +3548,10 @@ class ScopesTest {
           assertEquals(3.8, doubleattr.value)
           assertEquals("double", doubleattr.type)
 
+          val arrayattr = it.attributes?.get("arrayattr")!!
+          assertEquals(listOf("a", "b"), arrayattr.value)
+          assertEquals("array", arrayattr.type)
+
           val namedstrattr = it.attributes?.get("namedstrattr")!!
           assertEquals("namedstrval", namedstrattr.value)
           assertEquals("string", namedstrattr.type)
@@ -3507,6 +3567,10 @@ class ScopesTest {
           val nameddoubleattr = it.attributes?.get("nameddoubleattr")!!
           assertEquals(4.9, nameddoubleattr.value)
           assertEquals("double", nameddoubleattr.type)
+
+          val namedarrayattr = it.attributes?.get("namedarrayattr")!!
+          assertEquals(listOf("x", "y"), namedarrayattr.value)
+          assertEquals("array", namedarrayattr.type)
         },
         anyOrNull(),
         anyOrNull(),
@@ -3629,10 +3693,12 @@ class ScopesTest {
             SentryAttribute.booleanAttribute("boolattr", true),
             SentryAttribute.integerAttribute("intattr", 17),
             SentryAttribute.doubleAttribute("doubleattr", 3.8),
+            SentryAttribute.arrayAttribute("arrayattr", listOf("a", "b")),
             SentryAttribute.named("namedstrattr", "namedstrval"),
             SentryAttribute.named("namedboolattr", false),
             SentryAttribute.named("namedintattr", 18),
             SentryAttribute.named("nameddoubleattr", 4.9),
+            SentryAttribute.named("namedarrayattr", listOf("x", "y")),
           )
         ),
       )
@@ -3661,6 +3727,10 @@ class ScopesTest {
           assertEquals(3.8, doubleattr.value)
           assertEquals("double", doubleattr.type)
 
+          val arrayattr = it.attributes?.get("arrayattr")!!
+          assertEquals(listOf("a", "b"), arrayattr.value)
+          assertEquals("array", arrayattr.type)
+
           val namedstrattr = it.attributes?.get("namedstrattr")!!
           assertEquals("namedstrval", namedstrattr.value)
           assertEquals("string", namedstrattr.type)
@@ -3676,6 +3746,10 @@ class ScopesTest {
           val nameddoubleattr = it.attributes?.get("nameddoubleattr")!!
           assertEquals(4.9, nameddoubleattr.value)
           assertEquals("double", nameddoubleattr.type)
+
+          val namedarrayattr = it.attributes?.get("namedarrayattr")!!
+          assertEquals(listOf("x", "y"), namedarrayattr.value)
+          assertEquals("array", namedarrayattr.type)
         },
         anyOrNull(),
         anyOrNull(),
@@ -3798,10 +3872,12 @@ class ScopesTest {
             SentryAttribute.booleanAttribute("boolattr", true),
             SentryAttribute.integerAttribute("intattr", 17),
             SentryAttribute.doubleAttribute("doubleattr", 3.8),
+            SentryAttribute.arrayAttribute("arrayattr", listOf("a", "b")),
             SentryAttribute.named("namedstrattr", "namedstrval"),
             SentryAttribute.named("namedboolattr", false),
             SentryAttribute.named("namedintattr", 18),
             SentryAttribute.named("nameddoubleattr", 4.9),
+            SentryAttribute.named("namedarrayattr", listOf("x", "y")),
           )
         ),
       )
@@ -3830,6 +3906,10 @@ class ScopesTest {
           assertEquals(3.8, doubleattr.value)
           assertEquals("double", doubleattr.type)
 
+          val arrayattr = it.attributes?.get("arrayattr")!!
+          assertEquals(listOf("a", "b"), arrayattr.value)
+          assertEquals("array", arrayattr.type)
+
           val namedstrattr = it.attributes?.get("namedstrattr")!!
           assertEquals("namedstrval", namedstrattr.value)
           assertEquals("string", namedstrattr.type)
@@ -3845,6 +3925,10 @@ class ScopesTest {
           val nameddoubleattr = it.attributes?.get("nameddoubleattr")!!
           assertEquals(4.9, nameddoubleattr.value)
           assertEquals("double", nameddoubleattr.type)
+
+          val namedarrayattr = it.attributes?.get("namedarrayattr")!!
+          assertEquals(listOf("x", "y"), namedarrayattr.value)
+          assertEquals("array", namedarrayattr.type)
         },
         anyOrNull(),
         anyOrNull(),
diff --git a/sentry/src/test/java/io/sentry/SentryAttributeTypeTest.kt b/sentry/src/test/java/io/sentry/SentryAttributeTypeTest.kt
new file mode 100644
index 00000000000..d8d3a35db3b
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/SentryAttributeTypeTest.kt
@@ -0,0 +1,122 @@
+package io.sentry
+
+import java.math.BigDecimal
+import java.math.BigInteger
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class SentryAttributeTypeTest {
+
+  @Test
+  fun `inferFrom returns BOOLEAN for Boolean`() {
+    assertEquals(SentryAttributeType.BOOLEAN, SentryAttributeType.inferFrom(true))
+    assertEquals(SentryAttributeType.BOOLEAN, SentryAttributeType.inferFrom(false))
+  }
+
+  @Test
+  fun `inferFrom returns INTEGER for Integer`() {
+    assertEquals(SentryAttributeType.INTEGER, SentryAttributeType.inferFrom(42))
+  }
+
+  @Test
+  fun `inferFrom returns INTEGER for Long`() {
+    assertEquals(SentryAttributeType.INTEGER, SentryAttributeType.inferFrom(42L))
+  }
+
+  @Test
+  fun `inferFrom returns INTEGER for Short`() {
+    assertEquals(SentryAttributeType.INTEGER, SentryAttributeType.inferFrom(42.toShort()))
+  }
+
+  @Test
+  fun `inferFrom returns INTEGER for Byte`() {
+    assertEquals(SentryAttributeType.INTEGER, SentryAttributeType.inferFrom(42.toByte()))
+  }
+
+  @Test
+  fun `inferFrom returns INTEGER for BigInteger`() {
+    assertEquals(SentryAttributeType.INTEGER, SentryAttributeType.inferFrom(BigInteger.valueOf(42)))
+  }
+
+  @Test
+  fun `inferFrom returns INTEGER for AtomicInteger`() {
+    assertEquals(SentryAttributeType.INTEGER, SentryAttributeType.inferFrom(AtomicInteger(42)))
+  }
+
+  @Test
+  fun `inferFrom returns INTEGER for AtomicLong`() {
+    assertEquals(SentryAttributeType.INTEGER, SentryAttributeType.inferFrom(AtomicLong(42)))
+  }
+
+  @Test
+  fun `inferFrom returns DOUBLE for Double`() {
+    assertEquals(SentryAttributeType.DOUBLE, SentryAttributeType.inferFrom(3.14))
+  }
+
+  @Test
+  fun `inferFrom returns DOUBLE for Float`() {
+    assertEquals(SentryAttributeType.DOUBLE, SentryAttributeType.inferFrom(3.14f))
+  }
+
+  @Test
+  fun `inferFrom returns DOUBLE for BigDecimal`() {
+    assertEquals(
+      SentryAttributeType.DOUBLE,
+      SentryAttributeType.inferFrom(BigDecimal.valueOf(3.14)),
+    )
+  }
+
+  @Test
+  fun `inferFrom returns STRING for String`() {
+    assertEquals(SentryAttributeType.STRING, SentryAttributeType.inferFrom("hello"))
+  }
+
+  @Test
+  fun `inferFrom returns STRING for null`() {
+    assertEquals(SentryAttributeType.STRING, SentryAttributeType.inferFrom(null))
+  }
+
+  @Test
+  fun `inferFrom returns ARRAY for List of Strings`() {
+    assertEquals(SentryAttributeType.ARRAY, SentryAttributeType.inferFrom(listOf("a", "b")))
+  }
+
+  @Test
+  fun `inferFrom returns ARRAY for List of Integers`() {
+    assertEquals(SentryAttributeType.ARRAY, SentryAttributeType.inferFrom(listOf(1, 2, 3)))
+  }
+
+  @Test
+  fun `inferFrom returns ARRAY for Set of Booleans`() {
+    assertEquals(SentryAttributeType.ARRAY, SentryAttributeType.inferFrom(setOf(true, false)))
+  }
+
+  @Test
+  fun `inferFrom returns ARRAY for String array`() {
+    assertEquals(SentryAttributeType.ARRAY, SentryAttributeType.inferFrom(arrayOf("a", "b")))
+  }
+
+  @Test
+  fun `inferFrom returns ARRAY for int array`() {
+    assertEquals(SentryAttributeType.ARRAY, SentryAttributeType.inferFrom(intArrayOf(1, 2)))
+  }
+
+  @Test
+  fun `inferFrom returns ARRAY for empty list`() {
+    assertEquals(SentryAttributeType.ARRAY, SentryAttributeType.inferFrom(emptyList<String>()))
+  }
+
+  @Test
+  fun `inferFrom returns ARRAY for mixed-type list`() {
+    assertEquals(SentryAttributeType.ARRAY, SentryAttributeType.inferFrom(listOf("a", 1, true)))
+  }
+
+  @Test
+  fun `arrayAttribute factory accepts Object array`() {
+    val attr = SentryAttribute.arrayAttribute("key", arrayOf("a", "b"))
+    assertEquals("key", attr.name)
+    assertEquals(SentryAttributeType.ARRAY, attr.type)
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/protocol/SentryLogsSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/SentryLogsSerializationTest.kt
index c65a3cca709..ade038a408b 100644
--- a/sentry/src/test/java/io/sentry/protocol/SentryLogsSerializationTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/SentryLogsSerializationTest.kt
@@ -38,6 +38,7 @@ class SentryLogsSerializationTest {
                   "sentry.sdk.name" to
                     SentryLogEventAttributeValue("string", "sentry.java.spring-boot.jakarta"),
                   "sentry.environment" to SentryLogEventAttributeValue("string", "production"),
+                  "custom.array" to SentryLogEventAttributeValue("array", listOf("a", "b")),
                   "sentry.sdk.version" to SentryLogEventAttributeValue("string", "8.11.1"),
                   "sentry.trace.parent_span_id" to
                     SentryLogEventAttributeValue("string", "f28b86350e534671"),
diff --git a/sentry/src/test/resources/json/sentry_logs.json b/sentry/src/test/resources/json/sentry_logs.json
index e78f5af1b09..1674a4f5764 100644
--- a/sentry/src/test/resources/json/sentry_logs.json
+++ b/sentry/src/test/resources/json/sentry_logs.json
@@ -20,6 +20,11 @@
           "type": "string",
           "value": "production"
         },
+        "custom.array":
+        {
+          "type": "array",
+          "value": ["a", "b"]
+        },
         "sentry.sdk.version":
         {
           "type": "string",

From 46044dc3e57aaef0170354382869c0c195a6652f Mon Sep 17 00:00:00 2001
From: adinauer <2542832+adinauer@users.noreply.github.com>
Date: Wed, 4 Mar 2026 10:31:08 +0000
Subject: [PATCH 030/391] release: 8.34.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4353044f84e..c6d0c4104dd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.34.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 3faa0216ef2..9c919a6bde2 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.9.0
 
 # Release information
-versionName=8.33.0
+versionName=8.34.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 83884a0b907c939131bf81b60b8b5063e9a46e28 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 4 Mar 2026 16:27:26 +0100
Subject: [PATCH 031/391] Allow configuring shutdown and session flush timeouts
 externally and speed up tests (#4641)

* Add new modules for Spring 7 and Spring Boot 4

* Fix Spring 7 and Spring Boot 4 modules (#4602)

* Attempt to fix kotlin 2.2 issue (#4603)

* Fix Spring 7 and Spring Boot 4 modules

* Attempt to fix kotlin 2.2 issue

* Second attempt to fix Kotlin 2.2 (#4610)

* Second attempt to fix Kotlin 2.2

* Format code

* Third attempt at fixing Kotlin 2.2 compat (#4613)

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>

* Address compose-related issues

* Fix tests for Spring 7 and Spring Boot 4 (#4614)

* Second attempt to fix Kotlin 2.2

* Format code

* Third attempt at fixing Kotlin 2.2 compat

* Fix tests for Spring 7 and Spring Boot 4

* Move Spring 7 and Spring Boot 4 packages (#4615)

* Move Spring 7 and Spring Boot 4 packages

* Fix class not found due to OTel not supporting spring boot 4 yet (#4616)

* Format code

* some fixes

* change kotlin 1.8 to 1.9 and some cleanup

* ignore warnings about api level that is not relevant

* fix optional dependencies in SentryAutoConfiguration

* Update trace origin

* Remove duplicate e2e test config

* Update Strings for Spring 7 and Spring Boot 4

* Disable Spring Boot 4 agentless e2e tests for now

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: markushi <markus.hintersteiner@sentry.io>

* changelog

* fix ci

* add ignored span origins for Spring 7 and Spring Boot 4

* move changelog

* Speed up tests

* docs(changelog): Add entry for external shutdown/session-flush timeout options

Co-Authored-By: Claude <noreply@anthropic.com>

* ref: Use tracingEnabledRunner in boot4 and jakarta test classes

The tracingEnabledRunner was defined but unused in spring-boot-4 and
spring-boot-jakarta. Migrate the tracing tests to use it, matching
what was already done in spring-boot.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref: Add Millis suffix to ExternalOptions timeout fields

Rename shutdownTimeout/sessionFlushTimeout to
shutdownTimeoutMillis/sessionFlushTimeoutMillis for consistency
with SentryOptions naming convention.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref: Add Millis suffix to ExternalOptions timeout fields

Rename shutdownTimeout/sessionFlushTimeout to
shutdownTimeoutMillis/sessionFlushTimeoutMillis in ExternalOptions
for consistency with SentryOptions naming convention. Also rename
the sentry.properties keys from shutdown-timeout to
shutdown-timeout-millis and session-flush-timeout to
session-flush-timeout-millis.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs(changelog): Restructure timeout options changelog entry

List each configuration method separately for clarity.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(test): Use baseContextRunner for transport factory tests

Tests asserting AsyncHttpTransportFactory must not use contextRunner
which includes NoOpTransportConfiguration, as the NoOp bean would
override the auto-configured transport factory.

Co-Authored-By: Claude <noreply@anthropic.com>

* Format code

* ci: retrigger CI

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: markushi <markus.hintersteiner@sentry.io>
Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   4 +
 .../kotlin/io/sentry/jul/SentryHandlerTest.kt |  14 +-
 .../io/sentry/log4j2/SentryAppenderTest.kt    |  12 +-
 .../src/test/resources/sentry.properties      |   2 +
 .../io/sentry/logback/SentryAppenderTest.kt   |  20 ++-
 .../boot4/SentryAutoConfigurationTest.kt      | 161 ++++++++++--------
 ...tryLogbackAppenderAutoConfigurationTest.kt |  80 ++++++---
 .../SentryWebfluxAutoConfigurationTest.kt     |  77 ++++++---
 .../jakarta/SentryAutoConfigurationTest.kt    | 161 ++++++++++--------
 ...tryLogbackAppenderAutoConfigurationTest.kt |  80 ++++++---
 .../SentryWebfluxAutoConfigurationTest.kt     |  77 ++++++---
 .../boot/SentryAutoConfigurationTest.kt       | 114 ++++++++-----
 ...tryLogbackAppenderAutoConfigurationTest.kt |  80 ++++++---
 .../SentryWebfluxAutoConfigurationTest.kt     |  53 +++++-
 sentry/api/sentry.api                         |   4 +
 .../main/java/io/sentry/ExternalOptions.java  |  21 +++
 .../main/java/io/sentry/SentryOptions.java    |   6 +
 .../java/io/sentry/ExternalOptionsTest.kt     |  14 ++
 .../test/java/io/sentry/SentryOptionsTest.kt  |   4 +
 19 files changed, 667 insertions(+), 317 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c6d0c4104dd..338bbea4457 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@
 
 ### Features
 
+- Allow configuring shutdown and session flush timeouts externally ([#4641](https://github.com/getsentry/sentry-java/pull/4641))
+  - `sentry.properties`: `shutdown-timeout-millis`, `session-flush-timeout-millis`
+  - Environment variables: `SENTRY_SHUTDOWN_TIMEOUT_MILLIS`, `SENTRY_SESSION_FLUSH_TIMEOUT_MILLIS`
+  - Spring Boot `application.properties`: `sentry.shutdownTimeoutMillis`, `sentry.sessionFlushTimeoutMillis`
 - Add scope-level attributes API ([#5118](https://github.com/getsentry/sentry-java/pull/5118)) via ([#5148](https://github.com/getsentry/sentry-java/pull/5148))
   - Automatically include scope attributes in logs and metrics ([#5120](https://github.com/getsentry/sentry-java/pull/5120))
   - New APIs are `Sentry.setAttribute`, `Sentry.setAttributes`, `Sentry.removeAttribute`
diff --git a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt
index 889eb267d17..e86f06a4ab7 100644
--- a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt
+++ b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt
@@ -7,6 +7,7 @@ import io.sentry.SentryLogLevel
 import io.sentry.SentryOptions
 import io.sentry.checkEvent
 import io.sentry.checkLogs
+import io.sentry.test.applyTestOptions
 import io.sentry.test.initForTest
 import io.sentry.transport.ITransport
 import java.time.Instant
@@ -44,6 +45,7 @@ class SentryHandlerTest {
       val options = SentryOptions()
       options.dsn = "http://key@localhost/proj"
       options.setTransportFactory { _, _ -> transport }
+      applyTestOptions(options)
       contextTags?.forEach { options.addContextTag(it) }
       logger = Logger.getLogger("jul.SentryHandlerTest")
       handler = SentryHandler(options, configureWithLogManager, true)
@@ -415,7 +417,7 @@ class SentryHandlerTest {
     fixture = Fixture(minimumLevel = Level.FINEST)
     fixture.logger.finest("testing trace level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(
@@ -431,7 +433,7 @@ class SentryHandlerTest {
     fixture = Fixture(minimumLevel = Level.FINE)
     fixture.logger.fine("testing trace level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.DEBUG, event.items.first().level) })
@@ -442,7 +444,7 @@ class SentryHandlerTest {
     fixture = Fixture(minimumLevel = Level.CONFIG)
     fixture.logger.config("testing debug level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.DEBUG, event.items.first().level) })
@@ -453,7 +455,7 @@ class SentryHandlerTest {
     fixture = Fixture(minimumLevel = Level.INFO)
     fixture.logger.info("testing info level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.INFO, event.items.first().level) })
@@ -464,7 +466,7 @@ class SentryHandlerTest {
     fixture = Fixture(minimumLevel = Level.WARNING)
     fixture.logger.warning("testing warn level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.WARN, event.items.first().level) })
@@ -475,7 +477,7 @@ class SentryHandlerTest {
     fixture = Fixture(minimumLevel = Level.SEVERE)
     fixture.logger.severe("testing error level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.ERROR, event.items.first().level) })
diff --git a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt
index 4f67b8af368..9923f81f00f 100644
--- a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt
+++ b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt
@@ -248,7 +248,7 @@ class SentryAppenderTest {
     val logger = fixture.getSut(minimumLevel = Level.TRACE)
     logger.trace("testing trace level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(
@@ -267,7 +267,7 @@ class SentryAppenderTest {
     val logger = fixture.getSut(minimumLevel = Level.DEBUG)
     logger.debug("testing debug level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.DEBUG, event.items.first().level) })
@@ -278,7 +278,7 @@ class SentryAppenderTest {
     val logger = fixture.getSut(minimumLevel = Level.INFO)
     logger.info("testing info level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.INFO, event.items.first().level) })
@@ -289,7 +289,7 @@ class SentryAppenderTest {
     val logger = fixture.getSut(minimumLevel = Level.WARN)
     logger.warn("testing warn level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.WARN, event.items.first().level) })
@@ -300,7 +300,7 @@ class SentryAppenderTest {
     val logger = fixture.getSut(minimumLevel = Level.ERROR)
     logger.error("testing error level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.ERROR, event.items.first().level) })
@@ -311,7 +311,7 @@ class SentryAppenderTest {
     val logger = fixture.getSut(minimumLevel = Level.FATAL)
     logger.fatal("testing fatal level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { event -> assertEquals(SentryLogLevel.FATAL, event.items.first().level) })
diff --git a/sentry-log4j2/src/test/resources/sentry.properties b/sentry-log4j2/src/test/resources/sentry.properties
index 0163b4f2f84..9845650aace 100644
--- a/sentry-log4j2/src/test/resources/sentry.properties
+++ b/sentry-log4j2/src/test/resources/sentry.properties
@@ -1,2 +1,4 @@
 release=release from sentry.properties
 logs.enabled=true
+shutdown-timeout-millis=0
+session-flush-timeout-millis=0
diff --git a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
index b2e44ac80bc..e00d3aed49a 100644
--- a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
+++ b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
@@ -18,6 +18,7 @@ import io.sentry.SentryLogLevel
 import io.sentry.SentryOptions
 import io.sentry.checkEvent
 import io.sentry.checkLogs
+import io.sentry.test.applyTestOptions
 import io.sentry.test.initForTest
 import io.sentry.transport.ITransport
 import java.time.Instant
@@ -68,6 +69,7 @@ class SentryAppenderTest {
       options.dsn = dsn
       options.isSendDefaultPii = sendDefaultPii
       options.logs.isEnabled = enableLogs
+      applyTestOptions(options)
       contextTags?.forEach { options.addContextTag(it) }
       appender.setOptions(options)
       appender.setMinimumBreadcrumbLevel(minimumBreadcrumbLevel)
@@ -317,7 +319,7 @@ class SentryAppenderTest {
     fixture = Fixture(minimumLevel = Level.TRACE, enableLogs = true)
     fixture.logger.trace("testing trace level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { logs -> assertEquals(SentryLogLevel.TRACE, logs.items.first().level) })
@@ -328,7 +330,7 @@ class SentryAppenderTest {
     fixture = Fixture(minimumLevel = Level.DEBUG, enableLogs = true)
     fixture.logger.debug("testing debug level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { logs -> assertEquals(SentryLogLevel.DEBUG, logs.items.first().level) })
@@ -339,7 +341,7 @@ class SentryAppenderTest {
     fixture = Fixture(minimumLevel = Level.INFO, enableLogs = true)
     fixture.logger.info("testing info level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { logs -> assertEquals(SentryLogLevel.INFO, logs.items.first().level) })
@@ -350,7 +352,7 @@ class SentryAppenderTest {
     fixture = Fixture(minimumLevel = Level.WARN, enableLogs = true)
     fixture.logger.warn("testing warn level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { logs -> assertEquals(SentryLogLevel.WARN, logs.items.first().level) })
@@ -361,7 +363,7 @@ class SentryAppenderTest {
     fixture = Fixture(minimumLevel = Level.ERROR, enableLogs = true)
     fixture.logger.error("testing error level")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(checkLogs { logs -> assertEquals(SentryLogLevel.ERROR, logs.items.first().level) })
@@ -372,7 +374,7 @@ class SentryAppenderTest {
     fixture = Fixture(minimumLevel = Level.TRACE, enableLogs = true)
     fixture.logger.trace("Testing {} level", "TRACE")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(
@@ -394,7 +396,7 @@ class SentryAppenderTest {
     fixture = Fixture(minimumLevel = Level.TRACE, enableLogs = true, encoder = encoder)
     fixture.logger.trace("Testing {} level", "TRACE")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(
@@ -420,7 +422,7 @@ class SentryAppenderTest {
       )
     fixture.logger.trace("Testing {} level", "TRACE")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(
@@ -447,7 +449,7 @@ class SentryAppenderTest {
       )
     fixture.logger.trace("Testing {} level", "TRACE")
 
-    Sentry.flush(1000)
+    Sentry.flush(10)
 
     verify(fixture.transport)
       .send(
diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt
index 67200c2cd6d..a5566ef2f30 100644
--- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt
+++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt
@@ -89,7 +89,8 @@ import org.springframework.web.servlet.HandlerExceptionResolver
 
 class SentryAutoConfigurationTest {
 
-  private val contextRunner =
+  // Base context runner with performance optimizations
+  private val baseContextRunner =
     WebApplicationContextRunner()
       .withConfiguration(
         AutoConfigurations.of(
@@ -98,6 +99,42 @@ class SentryAutoConfigurationTest {
           SentryProfilerAutoConfiguration::class.java,
         )
       )
+      .withPropertyValues(
+        // Speed up tests by reducing timeouts and disabling expensive operations
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false", // Disable expensive module sending
+        "sentry.attach-stacktrace=false", // Disable expensive stacktrace collection
+        "sentry.attach-threads=false", // Disable expensive thread info
+        "sentry.enable-backpressure-handling=false",
+        "sentry.enable-spotlight=false",
+        "sentry.debug=false",
+        "sentry.max-breadcrumbs=0", // Disable breadcrumb collection for performance
+      )
+
+  // Use the optimized base runner by default
+  private val contextRunner =
+    baseContextRunner.withUserConfiguration(
+      NoOpTransportConfiguration::class.java
+    ) // Use no-op transport to avoid network calls
+
+  // Specialized context runners for different test categories
+  private val dsnEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
+
+  private val tracingEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
 
   @Test
   fun `scopes is not created when auto-configuration dsn is not set`() {
@@ -106,22 +143,17 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `scopes is created when dsn is provided`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(IScopes::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(IScopes::class.java) }
   }
 
   @Test
   fun `OptionsConfiguration is created if custom one with name sentryOptionsConfiguration is not provided`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(Sentry.OptionsConfiguration::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(Sentry.OptionsConfiguration::class.java) }
   }
 
   @Test
   fun `OptionsConfiguration with name sentryOptionsConfiguration is created if another one with different name is provided`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+    dsnEnabledRunner
       .withUserConfiguration(CustomOptionsConfigurationConfiguration::class.java)
       .run {
         assertThat(it).getBeans(Sentry.OptionsConfiguration::class.java).hasSize(2)
@@ -316,7 +348,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets SDK version on sent events`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withUserConfiguration(MockTransportConfiguration::class.java)
       .run {
@@ -432,7 +464,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets release on SentryEvents if Git integration is configured`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withUserConfiguration(
         MockTransportConfiguration::class.java,
@@ -451,7 +483,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets custom release on SentryEvents if release property is set and Git integration is configured`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.release=my-release")
       .withUserConfiguration(
         MockTransportConfiguration::class.java,
@@ -542,9 +574,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled, creates tracing filter`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasBean("sentryTracingFilter") }
+    tracingEnabledRunner.run { assertThat(it).hasBean("sentryTracingFilter") }
   }
 
   @Test
@@ -578,19 +608,16 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled and sentryTracingFilter already exists, does not create tracing filter`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withUserConfiguration(CustomSentryTracingFilter::class.java)
-      .run {
-        assertThat(it).hasBean("sentryTracingFilter")
-        val filter = it.getBean("sentryTracingFilter")
+    tracingEnabledRunner.withUserConfiguration(CustomSentryTracingFilter::class.java).run {
+      assertThat(it).hasBean("sentryTracingFilter")
+      val filter = it.getBean("sentryTracingFilter")
 
-        if (filter is FilterRegistrationBean<*>) {
-          assertThat(filter.filter).isNotInstanceOf(SentryTracingFilter::class.java)
-        } else {
-          assertThat(filter).isNotInstanceOf(SentryTracingFilter::class.java)
-        }
+      if (filter is FilterRegistrationBean<*>) {
+        assertThat(filter.filter).isNotInstanceOf(SentryTracingFilter::class.java)
+      } else {
+        assertThat(filter).isNotInstanceOf(SentryTracingFilter::class.java)
       }
+    }
   }
 
   @Test
@@ -610,9 +637,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled creates AOP beans to support @SentryTransaction`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSentryTransactionBeans() }
+    tracingEnabledRunner.run { assertThat(it).hasSentryTransactionBeans() }
   }
 
   @Test
@@ -639,16 +664,14 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when Spring AOP is not on the classpath, does not create AOP beans to support @SentryTransaction`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java))
-      .run { assertThat(it).doesNotHaveSentryTransactionBeans() }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java)).run {
+      assertThat(it).doesNotHaveSentryTransactionBeans()
+    }
   }
 
   @Test
   fun `when tracing is enabled and custom sentryTransactionPointcut is provided, sentryTransactionPointcut bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
+    tracingEnabledRunner
       .withUserConfiguration(CustomSentryPerformancePointcutConfiguration::class.java)
       .run {
         assertThat(it).hasBean("sentryTransactionPointcut")
@@ -659,9 +682,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled creates AOP beans to support @SentrySpan`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSentrySpanBeans() }
+    tracingEnabledRunner.run { assertThat(it).hasSentrySpanBeans() }
   }
 
   @Test
@@ -688,16 +709,14 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when Spring AOP is not on the classpath, does not create AOP beans to support @SentrySpan`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java))
-      .run { assertThat(it).doesNotHaveSentrySpanBeans() }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java)).run {
+      assertThat(it).doesNotHaveSentrySpanBeans()
+    }
   }
 
   @Test
   fun `when tracing is enabled and custom sentrySpanPointcut is provided, sentrySpanPointcut bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
+    tracingEnabledRunner
       .withUserConfiguration(CustomSentryPerformancePointcutConfiguration::class.java)
       .run {
         assertThat(it).hasBean("sentrySpanPointcut")
@@ -708,47 +727,44 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled and RestTemplate is on the classpath, SentrySpanRestTemplateCustomizer bean is created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSingleBean(SentrySpanRestTemplateCustomizer::class.java) }
+    tracingEnabledRunner.run {
+      assertThat(it).hasSingleBean(SentrySpanRestTemplateCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and RestTemplate is not on the classpath, SentrySpanRestTemplateCustomizer bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(RestTemplate::class.java))
-      .run { assertThat(it).doesNotHaveBean(SentrySpanRestTemplateCustomizer::class.java) }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(RestTemplate::class.java)).run {
+      assertThat(it).doesNotHaveBean(SentrySpanRestTemplateCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and RestClient is on the classpath, SentrySpanRestClientCustomizer bean is created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSingleBean(SentrySpanRestClientCustomizer::class.java) }
+    tracingEnabledRunner.run {
+      assertThat(it).hasSingleBean(SentrySpanRestClientCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and RestClient is not on the classpath, SentrySpanRestClientCustomizer bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(RestClient::class.java))
-      .run { assertThat(it).doesNotHaveBean(SentrySpanRestClientCustomizer::class.java) }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(RestClient::class.java)).run {
+      assertThat(it).doesNotHaveBean(SentrySpanRestClientCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and WebClient is on the classpath, SentrySpanWebClientCustomizer bean is created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSingleBean(SentrySpanWebClientCustomizer::class.java) }
+    tracingEnabledRunner.run {
+      assertThat(it).hasSingleBean(SentrySpanWebClientCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and WebClient is not on the classpath, SentrySpanWebClientCustomizer bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(WebClient::class.java))
-      .run { assertThat(it).doesNotHaveBean(SentrySpanWebClientCustomizer::class.java) }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(WebClient::class.java)).run {
+      assertThat(it).doesNotHaveBean(SentrySpanWebClientCustomizer::class.java)
+    }
   }
 
   @Test
@@ -764,7 +780,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when sentry-apache-http-client-5 is on the classpath, creates apache transport factory`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    baseContextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
       assertThat(it.getBean(SentryOptions::class.java).transportFactory)
         .isInstanceOf(ApacheHttpClientTransportFactory::class.java)
     }
@@ -772,7 +788,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when sentry-apache-http-client-5 is not on the classpath, does not create apache transport factory`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withClassLoader(FilteredClassLoader(ApacheHttpClientTransportFactory::class.java))
       .run {
@@ -783,7 +799,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when sentry-apache-http-client-5 is on the classpath and custom transport factory bean is set, does not create apache transport factory`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withUserConfiguration(MockTransportConfiguration::class.java)
       .run {
@@ -1234,6 +1250,15 @@ class SentryAutoConfigurationTest {
     @Bean open fun sentryTransport() = transport
   }
 
+  @Configuration(proxyBeanMethods = false)
+  open class NoOpTransportConfiguration {
+
+    @Bean
+    open fun noOpTransportFactory(): ITransportFactory {
+      return NoOpTransportFactory.getInstance()
+    }
+  }
+
   @Configuration(proxyBeanMethods = false)
   open class CustomBeforeSendCallbackConfiguration {
 
diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryLogbackAppenderAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryLogbackAppenderAutoConfigurationTest.kt
index 17e903d9a34..681932e6f89 100644
--- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryLogbackAppenderAutoConfigurationTest.kt
+++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryLogbackAppenderAutoConfigurationTest.kt
@@ -5,6 +5,8 @@ import ch.qos.logback.classic.Logger
 import ch.qos.logback.classic.LoggerContext
 import ch.qos.logback.classic.spi.ILoggingEvent
 import ch.qos.logback.core.Appender
+import io.sentry.ITransportFactory
+import io.sentry.NoOpTransportFactory
 import io.sentry.logback.SentryAppender
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -13,10 +15,13 @@ import org.slf4j.LoggerFactory
 import org.springframework.boot.autoconfigure.AutoConfigurations
 import org.springframework.boot.test.context.FilteredClassLoader
 import org.springframework.boot.test.context.runner.ApplicationContextRunner
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
 
 class SentryLogbackAppenderAutoConfigurationTest {
 
-  private val contextRunner =
+  // Base context runner with performance optimizations
+  private val baseContextRunner =
     ApplicationContextRunner()
       .withConfiguration(
         AutoConfigurations.of(
@@ -24,6 +29,35 @@ class SentryLogbackAppenderAutoConfigurationTest {
           SentryAutoConfiguration::class.java,
         )
       )
+      .withPropertyValues(
+        // Speed up tests by reducing timeouts and disabling expensive operations
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false", // Disable expensive module sending
+        "sentry.attach-stacktrace=false", // Disable expensive stacktrace collection
+        "sentry.attach-threads=false", // Disable expensive thread info
+        "sentry.enable-backpressure-handling=false",
+        "sentry.enable-spotlight=false",
+        "sentry.debug=false",
+        "sentry.max-breadcrumbs=0", // Disable breadcrumb collection for performance
+      )
+
+  // Use the optimized base runner by default
+  private val contextRunner =
+    baseContextRunner.withUserConfiguration(
+      NoOpTransportConfiguration::class.java
+    ) // Use no-op transport to avoid network calls
+
+  // Specialized context runner for tests requiring DSN
+  private val dsnEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
 
   private val rootLogger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME) as Logger
 
@@ -40,19 +74,15 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `configures SentryAppender`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       assertThat(rootLogger.getAppenders(SentryAppender::class.java)).hasSize(1)
     }
   }
 
   @Test
   fun `configures SentryAppender for configured loggers`() {
-    contextRunner
-      .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
-        "sentry.logging.loggers[0]=foo.bar",
-        "sentry.logging.loggers[1]=baz",
-      )
+    dsnEnabledRunner
+      .withPropertyValues("sentry.logging.loggers[0]=foo.bar", "sentry.logging.loggers[1]=baz")
       .run {
         val fooBarLogger = LoggerFactory.getLogger("foo.bar") as Logger
         val bazLogger = LoggerFactory.getLogger("baz") as Logger
@@ -65,23 +95,20 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `configures SentryAppender for none of the loggers if so configured`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.logging.loggers=")
-      .run {
-        val fooBarLogger = LoggerFactory.getLogger("foo.bar") as Logger
-        val bazLogger = LoggerFactory.getLogger("baz") as Logger
+    dsnEnabledRunner.withPropertyValues("sentry.logging.loggers=").run {
+      val fooBarLogger = LoggerFactory.getLogger("foo.bar") as Logger
+      val bazLogger = LoggerFactory.getLogger("baz") as Logger
 
-        assertThat(rootLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
-        assertThat(fooBarLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
-        assertThat(bazLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
-      }
+      assertThat(rootLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
+      assertThat(fooBarLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
+      assertThat(bazLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
+    }
   }
 
   @Test
   fun `sets SentryAppender properties`() {
-    contextRunner
+    dsnEnabledRunner
       .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
         "sentry.logging.minimum-event-level=info",
         "sentry.logging.minimum-breadcrumb-level=debug",
         "sentry.logging.minimum-level=error",
@@ -113,7 +140,7 @@ class SentryLogbackAppenderAutoConfigurationTest {
     sentryAppender.start()
     rootLogger.addAppender(sentryAppender)
 
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       val appenders = rootLogger.getAppenders(SentryAppender::class.java)
       assertThat(appenders).hasSize(1)
       assertThat(appenders.first().name).isEqualTo("customAppender")
@@ -122,7 +149,7 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `does not configure SentryAppender when logback is not on the classpath`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withClassLoader(FilteredClassLoader(LoggerContext::class.java))
       .run { assertThat(rootLogger.getAppenders(SentryAppender::class.java)).isEmpty() }
@@ -130,11 +157,20 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `does not configure SentryAppender when sentry-logback module is not on the classpath`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withClassLoader(FilteredClassLoader(SentryAppender::class.java))
       .run { assertThat(rootLogger.getAppenders(SentryAppender::class.java)).isEmpty() }
   }
+
+  @Configuration(proxyBeanMethods = false)
+  open class NoOpTransportConfiguration {
+
+    @Bean
+    open fun noOpTransportFactory(): ITransportFactory {
+      return NoOpTransportFactory.getInstance()
+    }
+  }
 }
 
 fun <T> Logger.getAppenders(clazz: Class<T>): List<Appender<ILoggingEvent>> {
diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryWebfluxAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryWebfluxAutoConfigurationTest.kt
index fbb3aedf375..a338208d8e4 100644
--- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryWebfluxAutoConfigurationTest.kt
+++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryWebfluxAutoConfigurationTest.kt
@@ -1,6 +1,8 @@
 package io.sentry.spring.boot4
 
 import io.micrometer.context.ThreadLocalAccessor
+import io.sentry.ITransportFactory
+import io.sentry.NoOpTransportFactory
 import io.sentry.spring7.webflux.SentryWebExceptionHandler
 import io.sentry.spring7.webflux.SentryWebFilter
 import io.sentry.spring7.webflux.SentryWebFilterWithThreadLocalAccessor
@@ -10,10 +12,13 @@ import org.springframework.boot.autoconfigure.AutoConfigurations
 import org.springframework.boot.test.context.FilteredClassLoader
 import org.springframework.boot.test.context.runner.ReactiveWebApplicationContextRunner
 import org.springframework.boot.webflux.autoconfigure.WebFluxAutoConfiguration
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
 import reactor.core.scheduler.Schedulers
 
 class SentryWebfluxAutoConfigurationTest {
-  private val contextRunner =
+  // Base context runner with performance optimizations
+  private val baseContextRunner =
     ReactiveWebApplicationContextRunner()
       .withConfiguration(
         AutoConfigurations.of(
@@ -22,10 +27,39 @@ class SentryWebfluxAutoConfigurationTest {
           SentryAutoConfiguration::class.java,
         )
       )
+      .withPropertyValues(
+        // Speed up tests by reducing timeouts and disabling expensive operations
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false", // Disable expensive module sending
+        "sentry.attach-stacktrace=false", // Disable expensive stacktrace collection
+        "sentry.attach-threads=false", // Disable expensive thread info
+        "sentry.enable-backpressure-handling=false",
+        "sentry.enable-spotlight=false",
+        "sentry.debug=false",
+        "sentry.max-breadcrumbs=0", // Disable breadcrumb collection for performance
+      )
+
+  // Use the optimized base runner by default
+  private val contextRunner =
+    baseContextRunner.withUserConfiguration(
+      NoOpTransportConfiguration::class.java
+    ) // Use no-op transport to avoid network calls
+
+  // Specialized context runner for tests requiring DSN
+  private val dsnEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
 
   @Test
   fun `configures sentryWebFilter`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       assertThat(it).hasSingleBean(SentryWebFilterWithThreadLocalAccessor::class.java)
       assertThat(it).doesNotHaveBean(SentryWebFilter::class.java)
     }
@@ -33,9 +67,7 @@ class SentryWebfluxAutoConfigurationTest {
 
   @Test
   fun `configures exception handler`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(SentryWebExceptionHandler::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(SentryWebExceptionHandler::class.java) }
   }
 
   @Test
@@ -59,28 +91,18 @@ class SentryWebfluxAutoConfigurationTest {
 
   @Test
   fun `configures web filter with ThreadLocalAccessor support if available and enabled`() {
-    contextRunner
-      .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
-        "sentry.reactive.thread-local-accessor-enabled=true",
-      )
-      .run {
-        assertThat(it).hasSingleBean(SentryWebFilterWithThreadLocalAccessor::class.java)
-        assertThat(it).doesNotHaveBean(SentryWebFilter::class.java)
-      }
+    dsnEnabledRunner.withPropertyValues("sentry.reactive.thread-local-accessor-enabled=true").run {
+      assertThat(it).hasSingleBean(SentryWebFilterWithThreadLocalAccessor::class.java)
+      assertThat(it).doesNotHaveBean(SentryWebFilter::class.java)
+    }
   }
 
   @Test
   fun `does not configure web filter with ThreadLocalAccessor support if disabled`() {
-    contextRunner
-      .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
-        "sentry.reactive.thread-local-accessor-enabled=false",
-      )
-      .run {
-        assertThat(it).doesNotHaveBean(SentryWebFilterWithThreadLocalAccessor::class.java)
-        assertThat(it).hasSingleBean(SentryWebFilter::class.java)
-      }
+    dsnEnabledRunner.withPropertyValues("sentry.reactive.thread-local-accessor-enabled=false").run {
+      assertThat(it).doesNotHaveBean(SentryWebFilterWithThreadLocalAccessor::class.java)
+      assertThat(it).hasSingleBean(SentryWebFilter::class.java)
+    }
   }
 
   @Test
@@ -93,4 +115,13 @@ class SentryWebfluxAutoConfigurationTest {
       .withClassLoader(FilteredClassLoader(ThreadLocalAccessor::class.java))
       .run { assertThat(it).doesNotHaveBean(SentryWebFilterWithThreadLocalAccessor::class.java) }
   }
+
+  @Configuration(proxyBeanMethods = false)
+  open class NoOpTransportConfiguration {
+
+    @Bean
+    open fun noOpTransportFactory(): ITransportFactory {
+      return NoOpTransportFactory.getInstance()
+    }
+  }
 }
diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt
index 4392598bf52..f37122812b1 100644
--- a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt
+++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt
@@ -93,7 +93,8 @@ import org.springframework.web.servlet.HandlerExceptionResolver
 
 class SentryAutoConfigurationTest {
 
-  private val contextRunner =
+  // Base context runner with performance optimizations
+  private val baseContextRunner =
     WebApplicationContextRunner()
       .withConfiguration(
         AutoConfigurations.of(
@@ -102,6 +103,42 @@ class SentryAutoConfigurationTest {
           SentryProfilerAutoConfiguration::class.java,
         )
       )
+      .withPropertyValues(
+        // Speed up tests by reducing timeouts and disabling expensive operations
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false", // Disable expensive module sending
+        "sentry.attach-stacktrace=false", // Disable expensive stacktrace collection
+        "sentry.attach-threads=false", // Disable expensive thread info
+        "sentry.enable-backpressure-handling=false",
+        "sentry.enable-spotlight=false",
+        "sentry.debug=false",
+        "sentry.max-breadcrumbs=0", // Disable breadcrumb collection for performance
+      )
+
+  // Use the optimized base runner by default
+  private val contextRunner =
+    baseContextRunner.withUserConfiguration(
+      NoOpTransportConfiguration::class.java
+    ) // Use no-op transport to avoid network calls
+
+  // Specialized context runners for different test categories
+  private val dsnEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
+
+  private val tracingEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
 
   @Test
   fun `scopes is not created when auto-configuration dsn is not set`() {
@@ -110,22 +147,17 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `scopes is created when dsn is provided`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(IScopes::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(IScopes::class.java) }
   }
 
   @Test
   fun `OptionsConfiguration is created if custom one with name sentryOptionsConfiguration is not provided`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(Sentry.OptionsConfiguration::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(Sentry.OptionsConfiguration::class.java) }
   }
 
   @Test
   fun `OptionsConfiguration with name sentryOptionsConfiguration is created if another one with different name is provided`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+    dsnEnabledRunner
       .withUserConfiguration(CustomOptionsConfigurationConfiguration::class.java)
       .run {
         assertThat(it).getBeans(Sentry.OptionsConfiguration::class.java).hasSize(2)
@@ -327,7 +359,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets SDK version on sent events`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withUserConfiguration(MockTransportConfiguration::class.java)
       .run {
@@ -454,7 +486,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets release on SentryEvents if Git integration is configured`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withUserConfiguration(
         MockTransportConfiguration::class.java,
@@ -473,7 +505,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets custom release on SentryEvents if release property is set and Git integration is configured`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.release=my-release")
       .withUserConfiguration(
         MockTransportConfiguration::class.java,
@@ -564,9 +596,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled, creates tracing filter`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasBean("sentryTracingFilter") }
+    tracingEnabledRunner.run { assertThat(it).hasBean("sentryTracingFilter") }
   }
 
   @Test
@@ -600,19 +630,16 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled and sentryTracingFilter already exists, does not create tracing filter`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withUserConfiguration(CustomSentryTracingFilter::class.java)
-      .run {
-        assertThat(it).hasBean("sentryTracingFilter")
-        val filter = it.getBean("sentryTracingFilter")
+    tracingEnabledRunner.withUserConfiguration(CustomSentryTracingFilter::class.java).run {
+      assertThat(it).hasBean("sentryTracingFilter")
+      val filter = it.getBean("sentryTracingFilter")
 
-        if (filter is FilterRegistrationBean<*>) {
-          assertThat(filter.filter).isNotInstanceOf(SentryTracingFilter::class.java)
-        } else {
-          assertThat(filter).isNotInstanceOf(SentryTracingFilter::class.java)
-        }
+      if (filter is FilterRegistrationBean<*>) {
+        assertThat(filter.filter).isNotInstanceOf(SentryTracingFilter::class.java)
+      } else {
+        assertThat(filter).isNotInstanceOf(SentryTracingFilter::class.java)
       }
+    }
   }
 
   @Test
@@ -632,9 +659,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled creates AOP beans to support @SentryTransaction`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSentryTransactionBeans() }
+    tracingEnabledRunner.run { assertThat(it).hasSentryTransactionBeans() }
   }
 
   @Test
@@ -661,16 +686,14 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when Spring AOP is not on the classpath, does not create AOP beans to support @SentryTransaction`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java))
-      .run { assertThat(it).doesNotHaveSentryTransactionBeans() }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java)).run {
+      assertThat(it).doesNotHaveSentryTransactionBeans()
+    }
   }
 
   @Test
   fun `when tracing is enabled and custom sentryTransactionPointcut is provided, sentryTransactionPointcut bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
+    tracingEnabledRunner
       .withUserConfiguration(CustomSentryPerformancePointcutConfiguration::class.java)
       .run {
         assertThat(it).hasBean("sentryTransactionPointcut")
@@ -681,9 +704,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled creates AOP beans to support @SentrySpan`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSentrySpanBeans() }
+    tracingEnabledRunner.run { assertThat(it).hasSentrySpanBeans() }
   }
 
   @Test
@@ -710,16 +731,14 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when Spring AOP is not on the classpath, does not create AOP beans to support @SentrySpan`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java))
-      .run { assertThat(it).doesNotHaveSentrySpanBeans() }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(ProceedingJoinPoint::class.java)).run {
+      assertThat(it).doesNotHaveSentrySpanBeans()
+    }
   }
 
   @Test
   fun `when tracing is enabled and custom sentrySpanPointcut is provided, sentrySpanPointcut bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
+    tracingEnabledRunner
       .withUserConfiguration(CustomSentryPerformancePointcutConfiguration::class.java)
       .run {
         assertThat(it).hasBean("sentrySpanPointcut")
@@ -730,47 +749,44 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled and RestTemplate is on the classpath, SentrySpanRestTemplateCustomizer bean is created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSingleBean(SentrySpanRestTemplateCustomizer::class.java) }
+    tracingEnabledRunner.run {
+      assertThat(it).hasSingleBean(SentrySpanRestTemplateCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and RestTemplate is not on the classpath, SentrySpanRestTemplateCustomizer bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(RestTemplate::class.java))
-      .run { assertThat(it).doesNotHaveBean(SentrySpanRestTemplateCustomizer::class.java) }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(RestTemplate::class.java)).run {
+      assertThat(it).doesNotHaveBean(SentrySpanRestTemplateCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and RestClient is on the classpath, SentrySpanRestClientCustomizer bean is created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSingleBean(SentrySpanRestClientCustomizer::class.java) }
+    tracingEnabledRunner.run {
+      assertThat(it).hasSingleBean(SentrySpanRestClientCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and RestClient is not on the classpath, SentrySpanRestClientCustomizer bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(RestClient::class.java))
-      .run { assertThat(it).doesNotHaveBean(SentrySpanRestClientCustomizer::class.java) }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(RestClient::class.java)).run {
+      assertThat(it).doesNotHaveBean(SentrySpanRestClientCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and WebClient is on the classpath, SentrySpanWebClientCustomizer bean is created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSingleBean(SentrySpanWebClientCustomizer::class.java) }
+    tracingEnabledRunner.run {
+      assertThat(it).hasSingleBean(SentrySpanWebClientCustomizer::class.java)
+    }
   }
 
   @Test
   fun `when tracing is enabled and WebClient is not on the classpath, SentrySpanWebClientCustomizer bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .withClassLoader(FilteredClassLoader(WebClient::class.java))
-      .run { assertThat(it).doesNotHaveBean(SentrySpanWebClientCustomizer::class.java) }
+    tracingEnabledRunner.withClassLoader(FilteredClassLoader(WebClient::class.java)).run {
+      assertThat(it).doesNotHaveBean(SentrySpanWebClientCustomizer::class.java)
+    }
   }
 
   @Test
@@ -786,7 +802,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when sentry-apache-http-client-5 is on the classpath, creates apache transport factory`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    baseContextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
       assertThat(it.getBean(SentryOptions::class.java).transportFactory)
         .isInstanceOf(ApacheHttpClientTransportFactory::class.java)
     }
@@ -794,7 +810,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when sentry-apache-http-client-5 is not on the classpath, does not create apache transport factory`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withClassLoader(FilteredClassLoader(ApacheHttpClientTransportFactory::class.java))
       .run {
@@ -805,7 +821,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when sentry-apache-http-client-5 is on the classpath and custom transport factory bean is set, does not create apache transport factory`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withUserConfiguration(MockTransportConfiguration::class.java)
       .run {
@@ -1256,6 +1272,15 @@ class SentryAutoConfigurationTest {
     @Bean open fun sentryTransport() = transport
   }
 
+  @Configuration(proxyBeanMethods = false)
+  open class NoOpTransportConfiguration {
+
+    @Bean
+    open fun noOpTransportFactory(): ITransportFactory {
+      return NoOpTransportFactory.getInstance()
+    }
+  }
+
   @Configuration(proxyBeanMethods = false)
   open class CustomBeforeSendCallbackConfiguration {
 
diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryLogbackAppenderAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryLogbackAppenderAutoConfigurationTest.kt
index 77712ac70c6..d8982d995c1 100644
--- a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryLogbackAppenderAutoConfigurationTest.kt
+++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryLogbackAppenderAutoConfigurationTest.kt
@@ -5,6 +5,8 @@ import ch.qos.logback.classic.Logger
 import ch.qos.logback.classic.LoggerContext
 import ch.qos.logback.classic.spi.ILoggingEvent
 import ch.qos.logback.core.Appender
+import io.sentry.ITransportFactory
+import io.sentry.NoOpTransportFactory
 import io.sentry.logback.SentryAppender
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -13,10 +15,13 @@ import org.slf4j.LoggerFactory
 import org.springframework.boot.autoconfigure.AutoConfigurations
 import org.springframework.boot.test.context.FilteredClassLoader
 import org.springframework.boot.test.context.runner.ApplicationContextRunner
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
 
 class SentryLogbackAppenderAutoConfigurationTest {
 
-  private val contextRunner =
+  // Base context runner with performance optimizations
+  private val baseContextRunner =
     ApplicationContextRunner()
       .withConfiguration(
         AutoConfigurations.of(
@@ -24,6 +29,35 @@ class SentryLogbackAppenderAutoConfigurationTest {
           SentryAutoConfiguration::class.java,
         )
       )
+      .withPropertyValues(
+        // Speed up tests by reducing timeouts and disabling expensive operations
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false", // Disable expensive module sending
+        "sentry.attach-stacktrace=false", // Disable expensive stacktrace collection
+        "sentry.attach-threads=false", // Disable expensive thread info
+        "sentry.enable-backpressure-handling=false",
+        "sentry.enable-spotlight=false",
+        "sentry.debug=false",
+        "sentry.max-breadcrumbs=0", // Disable breadcrumb collection for performance
+      )
+
+  // Use the optimized base runner by default
+  private val contextRunner =
+    baseContextRunner.withUserConfiguration(
+      NoOpTransportConfiguration::class.java
+    ) // Use no-op transport to avoid network calls
+
+  // Specialized context runner for tests requiring DSN
+  private val dsnEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
 
   private val rootLogger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME) as Logger
 
@@ -40,19 +74,15 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `configures SentryAppender`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       assertThat(rootLogger.getAppenders(SentryAppender::class.java)).hasSize(1)
     }
   }
 
   @Test
   fun `configures SentryAppender for configured loggers`() {
-    contextRunner
-      .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
-        "sentry.logging.loggers[0]=foo.bar",
-        "sentry.logging.loggers[1]=baz",
-      )
+    dsnEnabledRunner
+      .withPropertyValues("sentry.logging.loggers[0]=foo.bar", "sentry.logging.loggers[1]=baz")
       .run {
         val fooBarLogger = LoggerFactory.getLogger("foo.bar") as Logger
         val bazLogger = LoggerFactory.getLogger("baz") as Logger
@@ -65,23 +95,20 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `configures SentryAppender for none of the loggers if so configured`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.logging.loggers=")
-      .run {
-        val fooBarLogger = LoggerFactory.getLogger("foo.bar") as Logger
-        val bazLogger = LoggerFactory.getLogger("baz") as Logger
+    dsnEnabledRunner.withPropertyValues("sentry.logging.loggers=").run {
+      val fooBarLogger = LoggerFactory.getLogger("foo.bar") as Logger
+      val bazLogger = LoggerFactory.getLogger("baz") as Logger
 
-        assertThat(rootLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
-        assertThat(fooBarLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
-        assertThat(bazLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
-      }
+      assertThat(rootLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
+      assertThat(fooBarLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
+      assertThat(bazLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
+    }
   }
 
   @Test
   fun `sets SentryAppender properties`() {
-    contextRunner
+    dsnEnabledRunner
       .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
         "sentry.logging.minimum-event-level=info",
         "sentry.logging.minimum-breadcrumb-level=debug",
         "sentry.logging.minimum-level=error",
@@ -113,7 +140,7 @@ class SentryLogbackAppenderAutoConfigurationTest {
     sentryAppender.start()
     rootLogger.addAppender(sentryAppender)
 
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       val appenders = rootLogger.getAppenders(SentryAppender::class.java)
       assertThat(appenders).hasSize(1)
       assertThat(appenders.first().name).isEqualTo("customAppender")
@@ -122,7 +149,7 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `does not configure SentryAppender when logback is not on the classpath`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withClassLoader(FilteredClassLoader(LoggerContext::class.java))
       .run { assertThat(rootLogger.getAppenders(SentryAppender::class.java)).isEmpty() }
@@ -130,11 +157,20 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `does not configure SentryAppender when sentry-logback module is not on the classpath`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withClassLoader(FilteredClassLoader(SentryAppender::class.java))
       .run { assertThat(rootLogger.getAppenders(SentryAppender::class.java)).isEmpty() }
   }
+
+  @Configuration(proxyBeanMethods = false)
+  open class NoOpTransportConfiguration {
+
+    @Bean
+    open fun noOpTransportFactory(): ITransportFactory {
+      return NoOpTransportFactory.getInstance()
+    }
+  }
 }
 
 fun <T> Logger.getAppenders(clazz: Class<T>): List<Appender<ILoggingEvent>> {
diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryWebfluxAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryWebfluxAutoConfigurationTest.kt
index fd47317d1d2..6b67f2d6e91 100644
--- a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryWebfluxAutoConfigurationTest.kt
+++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryWebfluxAutoConfigurationTest.kt
@@ -1,6 +1,8 @@
 package io.sentry.spring.boot.jakarta
 
 import io.micrometer.context.ThreadLocalAccessor
+import io.sentry.ITransportFactory
+import io.sentry.NoOpTransportFactory
 import io.sentry.spring.jakarta.webflux.SentryWebExceptionHandler
 import io.sentry.spring.jakarta.webflux.SentryWebFilter
 import io.sentry.spring.jakarta.webflux.SentryWebFilterWithThreadLocalAccessor
@@ -10,10 +12,13 @@ import org.springframework.boot.autoconfigure.AutoConfigurations
 import org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration
 import org.springframework.boot.test.context.FilteredClassLoader
 import org.springframework.boot.test.context.runner.ReactiveWebApplicationContextRunner
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
 import reactor.core.scheduler.Schedulers
 
 class SentryWebfluxAutoConfigurationTest {
-  private val contextRunner =
+  // Base context runner with performance optimizations
+  private val baseContextRunner =
     ReactiveWebApplicationContextRunner()
       .withConfiguration(
         AutoConfigurations.of(
@@ -22,10 +27,39 @@ class SentryWebfluxAutoConfigurationTest {
           SentryAutoConfiguration::class.java,
         )
       )
+      .withPropertyValues(
+        // Speed up tests by reducing timeouts and disabling expensive operations
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false", // Disable expensive module sending
+        "sentry.attach-stacktrace=false", // Disable expensive stacktrace collection
+        "sentry.attach-threads=false", // Disable expensive thread info
+        "sentry.enable-backpressure-handling=false",
+        "sentry.enable-spotlight=false",
+        "sentry.debug=false",
+        "sentry.max-breadcrumbs=0", // Disable breadcrumb collection for performance
+      )
+
+  // Use the optimized base runner by default
+  private val contextRunner =
+    baseContextRunner.withUserConfiguration(
+      NoOpTransportConfiguration::class.java
+    ) // Use no-op transport to avoid network calls
+
+  // Specialized context runner for tests requiring DSN
+  private val dsnEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
 
   @Test
   fun `configures sentryWebFilter`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       assertThat(it).hasSingleBean(SentryWebFilterWithThreadLocalAccessor::class.java)
       assertThat(it).doesNotHaveBean(SentryWebFilter::class.java)
     }
@@ -33,9 +67,7 @@ class SentryWebfluxAutoConfigurationTest {
 
   @Test
   fun `configures exception handler`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(SentryWebExceptionHandler::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(SentryWebExceptionHandler::class.java) }
   }
 
   @Test
@@ -59,28 +91,18 @@ class SentryWebfluxAutoConfigurationTest {
 
   @Test
   fun `configures web filter with ThreadLocalAccessor support if available and enabled`() {
-    contextRunner
-      .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
-        "sentry.reactive.thread-local-accessor-enabled=true",
-      )
-      .run {
-        assertThat(it).hasSingleBean(SentryWebFilterWithThreadLocalAccessor::class.java)
-        assertThat(it).doesNotHaveBean(SentryWebFilter::class.java)
-      }
+    dsnEnabledRunner.withPropertyValues("sentry.reactive.thread-local-accessor-enabled=true").run {
+      assertThat(it).hasSingleBean(SentryWebFilterWithThreadLocalAccessor::class.java)
+      assertThat(it).doesNotHaveBean(SentryWebFilter::class.java)
+    }
   }
 
   @Test
   fun `does not configure web filter with ThreadLocalAccessor support if disabled`() {
-    contextRunner
-      .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
-        "sentry.reactive.thread-local-accessor-enabled=false",
-      )
-      .run {
-        assertThat(it).doesNotHaveBean(SentryWebFilterWithThreadLocalAccessor::class.java)
-        assertThat(it).hasSingleBean(SentryWebFilter::class.java)
-      }
+    dsnEnabledRunner.withPropertyValues("sentry.reactive.thread-local-accessor-enabled=false").run {
+      assertThat(it).doesNotHaveBean(SentryWebFilterWithThreadLocalAccessor::class.java)
+      assertThat(it).hasSingleBean(SentryWebFilter::class.java)
+    }
   }
 
   @Test
@@ -93,4 +115,13 @@ class SentryWebfluxAutoConfigurationTest {
       .withClassLoader(FilteredClassLoader(ThreadLocalAccessor::class.java))
       .run { assertThat(it).doesNotHaveBean(SentryWebFilterWithThreadLocalAccessor::class.java) }
   }
+
+  @Configuration(proxyBeanMethods = false)
+  open class NoOpTransportConfiguration {
+
+    @Bean
+    open fun noOpTransportFactory(): ITransportFactory {
+      return NoOpTransportFactory.getInstance()
+    }
+  }
 }
diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt
index 4dd4a9d6721..4ce0bf61208 100644
--- a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt
+++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt
@@ -92,7 +92,8 @@ import org.springframework.web.servlet.HandlerExceptionResolver
 
 class SentryAutoConfigurationTest {
 
-  private val contextRunner =
+  // Base context runner with performance optimizations
+  private val baseContextRunner =
     WebApplicationContextRunner()
       .withConfiguration(
         AutoConfigurations.of(
@@ -101,6 +102,42 @@ class SentryAutoConfigurationTest {
           SentryProfilerAutoConfiguration::class.java,
         )
       )
+      .withPropertyValues(
+        // Speed up tests by reducing timeouts and disabling expensive operations
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false", // Disable expensive module sending
+        "sentry.attach-stacktrace=false", // Disable expensive stacktrace collection
+        "sentry.attach-threads=false", // Disable expensive thread info
+        "sentry.enable-backpressure-handling=false",
+        "sentry.enable-spotlight=false",
+        "sentry.debug=false",
+        "sentry.max-breadcrumbs=0", // Disable breadcrumb collection for performance
+      )
+
+  // Use the optimized base runner by default
+  private val contextRunner =
+    baseContextRunner.withUserConfiguration(
+      NoOpTransportConfiguration::class.java
+    ) // Use no-op transport to avoid network calls
+
+  // Specialized context runners for different test categories
+  private val dsnEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
+
+  private val tracingEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
 
   @Test
   fun `scopes is not created when auto-configuration dsn is not set`() {
@@ -109,22 +146,17 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `scopes is created when dsn is provided`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(IScopes::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(IScopes::class.java) }
   }
 
   @Test
   fun `OptionsConfiguration is created if custom one with name sentryOptionsConfiguration is not provided`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(Sentry.OptionsConfiguration::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(Sentry.OptionsConfiguration::class.java) }
   }
 
   @Test
   fun `OptionsConfiguration with name sentryOptionsConfiguration is created if another one with different name is provided`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+    dsnEnabledRunner
       .withUserConfiguration(CustomOptionsConfigurationConfiguration::class.java)
       .run {
         assertThat(it).getBeans(Sentry.OptionsConfiguration::class.java).hasSize(2)
@@ -141,19 +173,18 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sentryOptionsConfiguration bean is configured before custom OptionsConfiguration`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+    dsnEnabledRunner
       .withUserConfiguration(CustomOptionsConfigurationConfiguration::class.java)
       .run {
         val options = it.getBean(SentryOptions::class.java)
         assertThat(options.beforeSend).isNull()
+        assertThat(options.shutdownTimeoutMillis).isEqualTo(0)
       }
   }
 
   @Test
   fun `OptionsConfiguration is not created if custom one with name sentryOptionsConfiguration is provided`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+    dsnEnabledRunner
       .withUserConfiguration(OverridingOptionsConfigurationConfiguration::class.java)
       .run {
         assertThat(it).hasSingleBean(Sentry.OptionsConfiguration::class.java)
@@ -279,7 +310,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracePropagationTargets are not set, default is returned`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       val options = it.getBean(SentryProperties::class.java)
       assertThat(options.tracePropagationTargets).isNotNull().containsOnly(".*")
     }
@@ -300,7 +331,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when traces sample rate is set to null and tracing is enabled, traces sample rate should be set to 0`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       val options = it.getBean(SentryProperties::class.java)
       assertThat(options.tracesSampleRate).isNull()
     }
@@ -318,7 +349,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets sentryClientName property on SentryOptions`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       assertThat(it.getBean(SentryOptions::class.java).sentryClientName)
         .isEqualTo("sentry.java.spring-boot/${BuildConfig.VERSION_NAME}")
     }
@@ -326,7 +357,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets SDK version on sent events`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withUserConfiguration(MockTransportConfiguration::class.java)
       .run {
@@ -453,7 +484,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets release on SentryEvents if Git integration is configured`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withUserConfiguration(
         MockTransportConfiguration::class.java,
@@ -472,7 +503,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `sets custom release on SentryEvents if release property is set and Git integration is configured`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.release=my-release")
       .withUserConfiguration(
         MockTransportConfiguration::class.java,
@@ -563,9 +594,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled, creates tracing filter`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasBean("sentryTracingFilter") }
+    tracingEnabledRunner.run { assertThat(it).hasBean("sentryTracingFilter") }
   }
 
   @Test
@@ -631,9 +660,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled creates AOP beans to support @SentryTransaction`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSentryTransactionBeans() }
+    tracingEnabledRunner.run { assertThat(it).hasSentryTransactionBeans() }
   }
 
   @Test
@@ -668,8 +695,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled and custom sentryTransactionPointcut is provided, sentryTransactionPointcut bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
+    tracingEnabledRunner
       .withUserConfiguration(CustomSentryPerformancePointcutConfiguration::class.java)
       .run {
         assertThat(it).hasBean("sentryTransactionPointcut")
@@ -680,9 +706,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled creates AOP beans to support @SentrySpan`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSentrySpanBeans() }
+    tracingEnabledRunner.run { assertThat(it).hasSentrySpanBeans() }
   }
 
   @Test
@@ -717,8 +741,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled and custom sentrySpanPointcut is provided, sentrySpanPointcut bean is not created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
+    tracingEnabledRunner
       .withUserConfiguration(CustomSentryPerformancePointcutConfiguration::class.java)
       .run {
         assertThat(it).hasBean("sentrySpanPointcut")
@@ -729,9 +752,9 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled and RestTemplate is on the classpath, SentrySpanRestTemplateCustomizer bean is created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSingleBean(SentrySpanRestTemplateCustomizer::class.java) }
+    tracingEnabledRunner.run {
+      assertThat(it).hasSingleBean(SentrySpanRestTemplateCustomizer::class.java)
+    }
   }
 
   @Test
@@ -744,9 +767,9 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when tracing is enabled and WebClient is on the classpath, SentrySpanWebClientCustomizer bean is created`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.traces-sample-rate=1.0")
-      .run { assertThat(it).hasSingleBean(SentrySpanWebClientCustomizer::class.java) }
+    tracingEnabledRunner.run {
+      assertThat(it).hasSingleBean(SentrySpanWebClientCustomizer::class.java)
+    }
   }
 
   @Test
@@ -770,7 +793,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when sentry-apache-http-client-5 is on the classpath, creates apache transport factory`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    baseContextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
       assertThat(it.getBean(SentryOptions::class.java).transportFactory)
         .isInstanceOf(ApacheHttpClientTransportFactory::class.java)
     }
@@ -778,7 +801,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when sentry-apache-http-client-5 is not on the classpath, does not create apache transport factory`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withClassLoader(FilteredClassLoader(ApacheHttpClientTransportFactory::class.java))
       .run {
@@ -789,7 +812,7 @@ class SentryAutoConfigurationTest {
 
   @Test
   fun `when sentry-apache-http-client-5 is on the classpath and custom transport factory bean is set, does not create apache transport factory`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withUserConfiguration(MockTransportConfiguration::class.java)
       .run {
@@ -1182,6 +1205,15 @@ class SentryAutoConfigurationTest {
     @Bean open fun sentryTransport() = transport
   }
 
+  @Configuration(proxyBeanMethods = false)
+  open class NoOpTransportConfiguration {
+
+    @Bean
+    open fun noOpTransportFactory(): ITransportFactory {
+      return NoOpTransportFactory.getInstance()
+    }
+  }
+
   @Configuration(proxyBeanMethods = false)
   open class CustomBeforeSendCallbackConfiguration {
 
diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryLogbackAppenderAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryLogbackAppenderAutoConfigurationTest.kt
index d353b3629f1..f68cad0ff90 100644
--- a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryLogbackAppenderAutoConfigurationTest.kt
+++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryLogbackAppenderAutoConfigurationTest.kt
@@ -5,6 +5,8 @@ import ch.qos.logback.classic.Logger
 import ch.qos.logback.classic.LoggerContext
 import ch.qos.logback.classic.spi.ILoggingEvent
 import ch.qos.logback.core.Appender
+import io.sentry.ITransportFactory
+import io.sentry.NoOpTransportFactory
 import io.sentry.logback.SentryAppender
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -13,10 +15,13 @@ import org.slf4j.LoggerFactory
 import org.springframework.boot.autoconfigure.AutoConfigurations
 import org.springframework.boot.test.context.FilteredClassLoader
 import org.springframework.boot.test.context.runner.ApplicationContextRunner
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
 
 class SentryLogbackAppenderAutoConfigurationTest {
 
-  private val contextRunner =
+  // Base context runner with performance optimizations
+  private val baseContextRunner =
     ApplicationContextRunner()
       .withConfiguration(
         AutoConfigurations.of(
@@ -24,6 +29,35 @@ class SentryLogbackAppenderAutoConfigurationTest {
           SentryAutoConfiguration::class.java,
         )
       )
+      .withPropertyValues(
+        // Speed up tests by reducing timeouts and disabling expensive operations
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false", // Disable expensive module sending
+        "sentry.attach-stacktrace=false", // Disable expensive stacktrace collection
+        "sentry.attach-threads=false", // Disable expensive thread info
+        "sentry.enable-backpressure-handling=false",
+        "sentry.enable-spotlight=false",
+        "sentry.debug=false",
+        "sentry.max-breadcrumbs=0", // Disable breadcrumb collection for performance
+      )
+
+  // Use the optimized base runner by default
+  private val contextRunner =
+    baseContextRunner.withUserConfiguration(
+      NoOpTransportConfiguration::class.java
+    ) // Use no-op transport to avoid network calls
+
+  // Specialized context runner for tests requiring DSN
+  private val dsnEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
 
   private val rootLogger = LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME) as Logger
 
@@ -40,19 +74,15 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `configures SentryAppender`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       assertThat(rootLogger.getAppenders(SentryAppender::class.java)).hasSize(1)
     }
   }
 
   @Test
   fun `configures SentryAppender for configured loggers`() {
-    contextRunner
-      .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
-        "sentry.logging.loggers[0]=foo.bar",
-        "sentry.logging.loggers[1]=baz",
-      )
+    dsnEnabledRunner
+      .withPropertyValues("sentry.logging.loggers[0]=foo.bar", "sentry.logging.loggers[1]=baz")
       .run {
         val fooBarLogger = LoggerFactory.getLogger("foo.bar") as Logger
         val bazLogger = LoggerFactory.getLogger("baz") as Logger
@@ -65,23 +95,20 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `configures SentryAppender for none of the loggers if so configured`() {
-    contextRunner
-      .withPropertyValues("sentry.dsn=http://key@localhost/proj", "sentry.logging.loggers=")
-      .run {
-        val fooBarLogger = LoggerFactory.getLogger("foo.bar") as Logger
-        val bazLogger = LoggerFactory.getLogger("baz") as Logger
+    dsnEnabledRunner.withPropertyValues("sentry.logging.loggers=").run {
+      val fooBarLogger = LoggerFactory.getLogger("foo.bar") as Logger
+      val bazLogger = LoggerFactory.getLogger("baz") as Logger
 
-        assertThat(rootLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
-        assertThat(fooBarLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
-        assertThat(bazLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
-      }
+      assertThat(rootLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
+      assertThat(fooBarLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
+      assertThat(bazLogger.getAppenders(SentryAppender::class.java)).hasSize(0)
+    }
   }
 
   @Test
   fun `sets SentryAppender properties`() {
-    contextRunner
+    dsnEnabledRunner
       .withPropertyValues(
-        "sentry.dsn=http://key@localhost/proj",
         "sentry.logging.minimum-event-level=info",
         "sentry.logging.minimum-breadcrumb-level=debug",
         "sentry.logging.minimum-level=error",
@@ -113,7 +140,7 @@ class SentryLogbackAppenderAutoConfigurationTest {
     sentryAppender.start()
     rootLogger.addAppender(sentryAppender)
 
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+    dsnEnabledRunner.run {
       val appenders = rootLogger.getAppenders(SentryAppender::class.java)
       assertThat(appenders).hasSize(1)
       assertThat(appenders.first().name).isEqualTo("customAppender")
@@ -122,7 +149,7 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `does not configure SentryAppender when logback is not on the classpath`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withClassLoader(FilteredClassLoader(LoggerContext::class.java))
       .run { assertThat(rootLogger.getAppenders(SentryAppender::class.java)).isEmpty() }
@@ -130,11 +157,20 @@ class SentryLogbackAppenderAutoConfigurationTest {
 
   @Test
   fun `does not configure SentryAppender when sentry-logback module is not on the classpath`() {
-    contextRunner
+    baseContextRunner
       .withPropertyValues("sentry.dsn=http://key@localhost/proj")
       .withClassLoader(FilteredClassLoader(SentryAppender::class.java))
       .run { assertThat(rootLogger.getAppenders(SentryAppender::class.java)).isEmpty() }
   }
+
+  @Configuration(proxyBeanMethods = false)
+  open class NoOpTransportConfiguration {
+
+    @Bean
+    open fun noOpTransportFactory(): ITransportFactory {
+      return NoOpTransportFactory.getInstance()
+    }
+  }
 }
 
 fun <T> Logger.getAppenders(clazz: Class<T>): List<Appender<ILoggingEvent>> {
diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryWebfluxAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryWebfluxAutoConfigurationTest.kt
index 320e8302b64..dea2c005881 100644
--- a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryWebfluxAutoConfigurationTest.kt
+++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryWebfluxAutoConfigurationTest.kt
@@ -1,5 +1,7 @@
 package io.sentry.spring.boot
 
+import io.sentry.ITransportFactory
+import io.sentry.NoOpTransportFactory
 import io.sentry.spring.webflux.SentryWebExceptionHandler
 import io.sentry.spring.webflux.SentryWebFilter
 import kotlin.test.Test
@@ -8,10 +10,13 @@ import org.springframework.boot.autoconfigure.AutoConfigurations
 import org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration
 import org.springframework.boot.test.context.FilteredClassLoader
 import org.springframework.boot.test.context.runner.ReactiveWebApplicationContextRunner
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
 import reactor.core.scheduler.Schedulers
 
 class SentryWebfluxAutoConfigurationTest {
-  private val contextRunner =
+  // Base context runner with performance optimizations
+  private val baseContextRunner =
     ReactiveWebApplicationContextRunner()
       .withConfiguration(
         AutoConfigurations.of(
@@ -20,19 +25,44 @@ class SentryWebfluxAutoConfigurationTest {
           SentryAutoConfiguration::class.java,
         )
       )
+      .withPropertyValues(
+        // Speed up tests by reducing timeouts and disabling expensive operations
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false", // Disable expensive module sending
+        "sentry.attach-stacktrace=false", // Disable expensive stacktrace collection
+        "sentry.attach-threads=false", // Disable expensive thread info
+        "sentry.enable-backpressure-handling=false",
+        "sentry.enable-spotlight=false",
+        "sentry.debug=false",
+        "sentry.max-breadcrumbs=0", // Disable breadcrumb collection for performance
+      )
+
+  // Use the optimized base runner by default
+  private val contextRunner =
+    baseContextRunner.withUserConfiguration(
+      NoOpTransportConfiguration::class.java
+    ) // Use no-op transport to avoid network calls
+
+  // Specialized context runner for tests requiring DSN
+  private val dsnEnabledRunner =
+    baseContextRunner
+      .withPropertyValues("sentry.dsn=http://key@localhost/proj")
+      .withUserConfiguration(
+        NoOpTransportConfiguration::class.java
+      ) // Use no-op transport to avoid network calls
 
   @Test
   fun `configures sentryWebFilter`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(SentryWebFilter::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(SentryWebFilter::class.java) }
   }
 
   @Test
   fun `configures exception handler`() {
-    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
-      assertThat(it).hasSingleBean(SentryWebExceptionHandler::class.java)
-    }
+    dsnEnabledRunner.run { assertThat(it).hasSingleBean(SentryWebExceptionHandler::class.java) }
   }
 
   @Test
@@ -53,4 +83,13 @@ class SentryWebfluxAutoConfigurationTest {
       assertThat(it).doesNotHaveBean(SentryWebFilter::class.java)
     }
   }
+
+  @Configuration(proxyBeanMethods = false)
+  open class NoOpTransportConfiguration {
+
+    @Bean
+    open fun noOpTransportFactory(): ITransportFactory {
+      return NoOpTransportFactory.getInstance()
+    }
+  }
 }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index a7bbb6c6cfa..73eb9c61446 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -512,6 +512,8 @@ public final class io/sentry/ExternalOptions {
 	public fun getSampleRate ()Ljava/lang/Double;
 	public fun getSendClientReports ()Ljava/lang/Boolean;
 	public fun getServerName ()Ljava/lang/String;
+	public fun getSessionFlushTimeoutMillis ()Ljava/lang/Long;
+	public fun getShutdownTimeoutMillis ()Ljava/lang/Long;
 	public fun getSpotlightConnectionUrl ()Ljava/lang/String;
 	public fun getTags ()Ljava/util/Map;
 	public fun getTracePropagationTargets ()Ljava/util/List;
@@ -563,6 +565,8 @@ public final class io/sentry/ExternalOptions {
 	public fun setSendDefaultPii (Ljava/lang/Boolean;)V
 	public fun setSendModules (Ljava/lang/Boolean;)V
 	public fun setServerName (Ljava/lang/String;)V
+	public fun setSessionFlushTimeoutMillis (Ljava/lang/Long;)V
+	public fun setShutdownTimeoutMillis (Ljava/lang/Long;)V
 	public fun setSpotlightConnectionUrl (Ljava/lang/String;)V
 	public fun setTag (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setTracesSampleRate (Ljava/lang/Double;)V
diff --git a/sentry/src/main/java/io/sentry/ExternalOptions.java b/sentry/src/main/java/io/sentry/ExternalOptions.java
index 9eaf26b202f..8f16bcede01 100644
--- a/sentry/src/main/java/io/sentry/ExternalOptions.java
+++ b/sentry/src/main/java/io/sentry/ExternalOptions.java
@@ -35,6 +35,8 @@ public final class ExternalOptions {
   private final @NotNull List<String> contextTags = new CopyOnWriteArrayList<>();
   private @Nullable String proguardUuid;
   private @Nullable Long idleTimeout;
+  private @Nullable Long shutdownTimeoutMillis;
+  private @Nullable Long sessionFlushTimeoutMillis;
   private final @NotNull Set<Class<? extends Throwable>> ignoredExceptionsForType =
       new CopyOnWriteArraySet<>();
   private @Nullable List<String> ignoredErrors;
@@ -137,6 +139,9 @@ public final class ExternalOptions {
       options.addBundleId(bundleId);
     }
     options.setIdleTimeout(propertiesProvider.getLongProperty("idle-timeout"));
+    options.setShutdownTimeoutMillis(propertiesProvider.getLongProperty("shutdown-timeout-millis"));
+    options.setSessionFlushTimeoutMillis(
+        propertiesProvider.getLongProperty("session-flush-timeout-millis"));
 
     options.setIgnoredErrors(propertiesProvider.getListOrNull("ignored-errors"));
 
@@ -410,6 +415,22 @@ public void setIdleTimeout(final @Nullable Long idleTimeout) {
     this.idleTimeout = idleTimeout;
   }
 
+  public @Nullable Long getShutdownTimeoutMillis() {
+    return shutdownTimeoutMillis;
+  }
+
+  public void setShutdownTimeoutMillis(final @Nullable Long shutdownTimeoutMillis) {
+    this.shutdownTimeoutMillis = shutdownTimeoutMillis;
+  }
+
+  public @Nullable Long getSessionFlushTimeoutMillis() {
+    return sessionFlushTimeoutMillis;
+  }
+
+  public void setSessionFlushTimeoutMillis(final @Nullable Long sessionFlushTimeoutMillis) {
+    this.sessionFlushTimeoutMillis = sessionFlushTimeoutMillis;
+  }
+
   public @Nullable List<String> getIgnoredErrors() {
     return ignoredErrors;
   }
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 7883ed6b95b..a831a11ea8e 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -3430,6 +3430,12 @@ public void merge(final @NotNull ExternalOptions options) {
     if (options.getIdleTimeout() != null) {
       setIdleTimeout(options.getIdleTimeout());
     }
+    if (options.getShutdownTimeoutMillis() != null) {
+      setShutdownTimeoutMillis(options.getShutdownTimeoutMillis());
+    }
+    if (options.getSessionFlushTimeoutMillis() != null) {
+      setSessionFlushTimeoutMillis(options.getSessionFlushTimeoutMillis());
+    }
     for (String bundleId : options.getBundleIds()) {
       addBundleId(bundleId);
     }
diff --git a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
index 5a8bb1c7872..9612a052624 100644
--- a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
@@ -180,6 +180,20 @@ class ExternalOptionsTest {
     withPropertiesFile("idle-timeout=2000") { assertEquals(2000L, it.idleTimeout) }
   }
 
+  @Test
+  fun `creates options with shutdownTimeoutMillis using external properties`() {
+    withPropertiesFile("shutdown-timeout-millis=2000") {
+      assertEquals(2000L, it.shutdownTimeoutMillis)
+    }
+  }
+
+  @Test
+  fun `creates options with sessionFlushTimeoutMillis using external properties`() {
+    withPropertiesFile("session-flush-timeout-millis=2000") {
+      assertEquals(2000L, it.sessionFlushTimeoutMillis)
+    }
+  }
+
   @Test
   fun `creates options with ignored exception types using external properties`() {
     val logger = mock<ILogger>()
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index 2f5b3579cb3..960b2838e2a 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -387,6 +387,8 @@ class SentryOptionsTest {
     externalOptions.addContextTag("requestId")
     externalOptions.proguardUuid = "1234"
     externalOptions.idleTimeout = 1500L
+    externalOptions.shutdownTimeoutMillis = 1499L
+    externalOptions.sessionFlushTimeoutMillis = 1498L
     externalOptions.bundleIds.addAll(
       listOf("12ea7a02-46ac-44c0-a5bb-6d1fd9586411 ", " faa3ab42-b1bd-4659-af8e-1682324aa744")
     )
@@ -443,6 +445,8 @@ class SentryOptionsTest {
     assertEquals(listOf("userId", "requestId"), options.contextTags)
     assertEquals("1234", options.proguardUuid)
     assertEquals(1500L, options.idleTimeout)
+    assertEquals(1499L, options.shutdownTimeoutMillis)
+    assertEquals(1498L, options.sessionFlushTimeoutMillis)
     assertEquals(
       setOf("12ea7a02-46ac-44c0-a5bb-6d1fd9586411", "faa3ab42-b1bd-4659-af8e-1682324aa744"),
       options.bundleIds,

From a415905783b6670cc29ba45372a87f83591682d2 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 5 Mar 2026 10:51:35 +0100
Subject: [PATCH 032/391] fix(screenshot): Add dontwarn replay rules to
 sentry-android-core (#5153)

* fix(screenshot): Add dontwarn replay rules to sentry-android-core

* Changelog

* Changelog
---
 CHANGELOG.md                                                | 6 ++++++
 sentry-android-core/proguard-rules.pro                      | 4 ++++
 .../sentry-uitest-android/proguard-rules.pro                | 4 ----
 3 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 338bbea4457..4da8060b6b2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Android: Add proguard rules to prevent error about missing Replay classes ([#5153](https://github.com/getsentry/sentry-java/pull/5153))
+
 ## 8.34.0
 
 ### Features
diff --git a/sentry-android-core/proguard-rules.pro b/sentry-android-core/proguard-rules.pro
index 25086b4d2b6..2b49c949db9 100644
--- a/sentry-android-core/proguard-rules.pro
+++ b/sentry-android-core/proguard-rules.pro
@@ -80,6 +80,10 @@
 ##---------------Begin: proguard configuration for sentry-android-replay  ----------
 -dontwarn io.sentry.android.replay.ReplayIntegration
 -dontwarn io.sentry.android.replay.DefaultReplayBreadcrumbConverter
+-dontwarn io.sentry.android.replay.util.MaskRenderer
+-dontwarn io.sentry.android.replay.util.ViewsKt
+-dontwarn io.sentry.android.replay.viewhierarchy.ViewHierarchyNode$Companion
+-dontwarn io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
 -keepnames class io.sentry.android.replay.ReplayIntegration
 ##---------------End: proguard configuration for sentry-android-replay  ----------
 
diff --git a/sentry-android-integration-tests/sentry-uitest-android/proguard-rules.pro b/sentry-android-integration-tests/sentry-uitest-android/proguard-rules.pro
index 396c9025eaf..5de2dac4bdb 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/proguard-rules.pro
+++ b/sentry-android-integration-tests/sentry-uitest-android/proguard-rules.pro
@@ -40,8 +40,4 @@
 -dontwarn org.mockito.internal.**
 -dontwarn org.jetbrains.annotations.**
 -dontwarn io.sentry.android.replay.ReplayIntegration
--dontwarn io.sentry.android.replay.util.MaskRenderer
--dontwarn io.sentry.android.replay.util.ViewsKt
--dontwarn io.sentry.android.replay.viewhierarchy.ViewHierarchyNode$Companion
--dontwarn io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
 -keep class curtains.** { *; }

From b8bd8c438a49529e3f4575413b6f474a2a8ee031 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 5 Mar 2026 13:49:19 +0100
Subject: [PATCH 033/391] fix(logging): Use ImmediateExecutorService in logging
 tests and fix Log4j2 scopes usage (#5158)

* fix(logging): Use ImmediateExecutorService in logging tests and fix Log4j2 scopes usage

Allow injecting ISentryExecutorService into LoggerBatchProcessor for deterministic test execution. Fix Log4j2 SentryAppender to use scopes instance instead of static Sentry calls for logging.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(log4j2): Move super.start() into start(OptionsConfiguration) overload

Ensures the appender is marked as started regardless of which entry
point is used, preventing loggerContext.start() from re-triggering
the no-arg start() and reinitializing Sentry without the test executor.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .../kotlin/io/sentry/jul/SentryHandlerTest.kt |  6 +++
 .../java/io/sentry/log4j2/SentryAppender.java | 53 +++++++++++--------
 .../io/sentry/log4j2/SentryAppenderTest.kt    | 12 ++++-
 .../io/sentry/logback/SentryAppenderTest.kt   |  6 +++
 sentry/api/sentry.api                         |  1 +
 .../sentry/logger/LoggerBatchProcessor.java   | 13 ++++-
 6 files changed, 68 insertions(+), 23 deletions(-)

diff --git a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt
index e86f06a4ab7..ab160faac40 100644
--- a/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt
+++ b/sentry-jul/src/test/kotlin/io/sentry/jul/SentryHandlerTest.kt
@@ -7,6 +7,9 @@ import io.sentry.SentryLogLevel
 import io.sentry.SentryOptions
 import io.sentry.checkEvent
 import io.sentry.checkLogs
+import io.sentry.logger.ILoggerBatchProcessorFactory
+import io.sentry.logger.LoggerBatchProcessor
+import io.sentry.test.ImmediateExecutorService
 import io.sentry.test.applyTestOptions
 import io.sentry.test.initForTest
 import io.sentry.transport.ITransport
@@ -45,6 +48,9 @@ class SentryHandlerTest {
       val options = SentryOptions()
       options.dsn = "http://key@localhost/proj"
       options.setTransportFactory { _, _ -> transport }
+      options.logs.loggerBatchProcessorFactory = ILoggerBatchProcessorFactory { options, client ->
+        LoggerBatchProcessor(options, client, ImmediateExecutorService())
+      }
       applyTestOptions(options)
       contextTags?.forEach { options.addContextTag(it) }
       logger = Logger.getLogger("jul.SentryHandlerTest")
diff --git a/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java b/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java
index 6885cdb81fd..df0f9eeb2d2 100644
--- a/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java
+++ b/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java
@@ -164,25 +164,37 @@ public SentryAppender(
 
   @Override
   public void start() {
+    start(getOptionsConfiguration(null));
+  }
+
+  @NotNull
+  Sentry.OptionsConfiguration<SentryOptions> getOptionsConfiguration(
+      final @Nullable Sentry.OptionsConfiguration<SentryOptions> additionalOptionsConfiguration) {
+    return options -> {
+      options.setEnableExternalConfiguration(true);
+      options.setInitPriority(InitPriority.LOWEST);
+      options.setDsn(dsn);
+      if (debug != null) {
+        options.setDebug(debug);
+      }
+      options.setSentryClientName(
+          BuildConfig.SENTRY_LOG4J2_SDK_NAME + "/" + BuildConfig.VERSION_NAME);
+      options.setSdkVersion(createSdkVersion(options));
+      if (contextTags != null) {
+        for (final String contextTag : contextTags) {
+          options.addContextTag(contextTag);
+        }
+      }
+      Optional.ofNullable(transportFactory).ifPresent(options::setTransportFactory);
+      if (additionalOptionsConfiguration != null) {
+        additionalOptionsConfiguration.configure(options);
+      }
+    };
+  }
+
+  void start(final @NotNull Sentry.OptionsConfiguration<SentryOptions> optionsConfiguration) {
     try {
-      Sentry.init(
-          options -> {
-            options.setEnableExternalConfiguration(true);
-            options.setInitPriority(InitPriority.LOWEST);
-            options.setDsn(dsn);
-            if (debug != null) {
-              options.setDebug(debug);
-            }
-            options.setSentryClientName(
-                BuildConfig.SENTRY_LOG4J2_SDK_NAME + "/" + BuildConfig.VERSION_NAME);
-            options.setSdkVersion(createSdkVersion(options));
-            if (contextTags != null) {
-              for (final String contextTag : contextTags) {
-                options.addContextTag(contextTag);
-              }
-            }
-            Optional.ofNullable(transportFactory).ifPresent(options::setTransportFactory);
-          });
+      Sentry.init(optionsConfiguration);
     } catch (IllegalArgumentException e) {
       final @Nullable String errorMessage = e.getMessage();
       if (errorMessage == null || !errorMessage.startsWith("DSN is required.")) {
@@ -235,14 +247,13 @@ protected void captureLog(@NotNull LogEvent loggingEvent) {
     }
 
     final @NotNull Map<String, String> contextData = loggingEvent.getContextData().toMap();
-    final @NotNull List<String> contextTags =
-        ScopesAdapter.getInstance().getOptions().getContextTags();
+    final @NotNull List<String> contextTags = scopes.getOptions().getContextTags();
     LoggerPropertiesUtil.applyPropertiesToAttributes(attributes, contextTags, contextData);
 
     final @NotNull SentryLogParameters params = SentryLogParameters.create(attributes);
     params.setOrigin("auto.log.log4j2");
 
-    Sentry.logger().log(sentryLevel, params, formattedMessage, arguments);
+    scopes.logger().log(sentryLevel, params, formattedMessage, arguments);
   }
 
   /**
diff --git a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt
index 9923f81f00f..c32459ea022 100644
--- a/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt
+++ b/sentry-log4j2/src/test/kotlin/io/sentry/log4j2/SentryAppenderTest.kt
@@ -8,6 +8,9 @@ import io.sentry.SentryLevel
 import io.sentry.SentryLogLevel
 import io.sentry.checkEvent
 import io.sentry.checkLogs
+import io.sentry.logger.ILoggerBatchProcessorFactory
+import io.sentry.logger.LoggerBatchProcessor
+import io.sentry.test.ImmediateExecutorService
 import io.sentry.test.initForTest
 import io.sentry.transport.ITransport
 import java.time.Instant
@@ -93,7 +96,14 @@ class SentryAppenderTest {
 
       loggerContext.updateLoggers(config)
 
-      appender.start()
+      appender.start(
+        appender.getOptionsConfiguration { options ->
+          options.logs.loggerBatchProcessorFactory =
+            ILoggerBatchProcessorFactory { options, client ->
+              LoggerBatchProcessor(options, client, ImmediateExecutorService())
+            }
+        }
+      )
       loggerContext.start()
 
       return LogManager.getContext().getLogger(SentryAppenderTest::class.java.name)
diff --git a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
index e00d3aed49a..e93d6ef2db1 100644
--- a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
+++ b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
@@ -18,6 +18,9 @@ import io.sentry.SentryLogLevel
 import io.sentry.SentryOptions
 import io.sentry.checkEvent
 import io.sentry.checkLogs
+import io.sentry.logger.ILoggerBatchProcessorFactory
+import io.sentry.logger.LoggerBatchProcessor
+import io.sentry.test.ImmediateExecutorService
 import io.sentry.test.applyTestOptions
 import io.sentry.test.initForTest
 import io.sentry.transport.ITransport
@@ -69,6 +72,9 @@ class SentryAppenderTest {
       options.dsn = dsn
       options.isSendDefaultPii = sendDefaultPii
       options.logs.isEnabled = enableLogs
+      options.logs.loggerBatchProcessorFactory = ILoggerBatchProcessorFactory { options, client ->
+        LoggerBatchProcessor(options, client, ImmediateExecutorService())
+      }
       applyTestOptions(options)
       contextTags?.forEach { options.addContextTag(it) }
       appender.setOptions(options)
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 73eb9c61446..c8b194f32d3 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -5259,6 +5259,7 @@ public class io/sentry/logger/LoggerBatchProcessor : io/sentry/logger/ILoggerBat
 	public static final field MAX_QUEUE_SIZE I
 	protected final field options Lio/sentry/SentryOptions;
 	public fun <init> (Lio/sentry/SentryOptions;Lio/sentry/ISentryClient;)V
+	public fun <init> (Lio/sentry/SentryOptions;Lio/sentry/ISentryClient;Lio/sentry/ISentryExecutorService;)V
 	public fun add (Lio/sentry/SentryLogEvent;)V
 	public fun close (Z)V
 	public fun flush (J)V
diff --git a/sentry/src/main/java/io/sentry/logger/LoggerBatchProcessor.java b/sentry/src/main/java/io/sentry/logger/LoggerBatchProcessor.java
index 1f9b8fe7ce2..81ae5b73c1a 100644
--- a/sentry/src/main/java/io/sentry/logger/LoggerBatchProcessor.java
+++ b/sentry/src/main/java/io/sentry/logger/LoggerBatchProcessor.java
@@ -21,8 +21,10 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.TimeUnit;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
 
 @Open
 public class LoggerBatchProcessor implements ILoggerBatchProcessor {
@@ -44,10 +46,19 @@ public class LoggerBatchProcessor implements ILoggerBatchProcessor {
 
   public LoggerBatchProcessor(
       final @NotNull SentryOptions options, final @NotNull ISentryClient client) {
+    this(options, client, new SentryExecutorService(options));
+  }
+
+  @ApiStatus.Internal
+  @TestOnly
+  public LoggerBatchProcessor(
+      final @NotNull SentryOptions options,
+      final @NotNull ISentryClient client,
+      final @NotNull ISentryExecutorService executorService) {
     this.options = options;
     this.client = client;
     this.queue = new ConcurrentLinkedQueue<>();
-    this.executorService = new SentryExecutorService(options);
+    this.executorService = executorService;
   }
 
   @Override

From 37a4609a5b7f35067285ca6e4886348a1a48df51 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 5 Mar 2026 14:17:29 +0100
Subject: [PATCH 034/391] chore(ci): Kill BinarySizeTest in favour of Size
 Analysis status check (#5159)

---
 sentry-android-integration-tests/metrics-test.yml | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/sentry-android-integration-tests/metrics-test.yml b/sentry-android-integration-tests/metrics-test.yml
index 9842063d58b..a73ca1ef7c0 100644
--- a/sentry-android-integration-tests/metrics-test.yml
+++ b/sentry-android-integration-tests/metrics-test.yml
@@ -10,7 +10,3 @@ startupTimeTest:
   runs: 50
   diffMin: 0
   diffMax: 150
-
-binarySizeTest:
-  diffMin: 600 KiB
-  diffMax: 850 KiB

From 872b0841f71a53269afd906cf7b61a450c004dd2 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 5 Mar 2026 14:34:25 +0100
Subject: [PATCH 035/391] fix(sessions): Finalize previous session even when
 auto session tracking is disabled (#5154)

* fix(core): Finalize previous session even when auto session tracking is disabled

The `isEnableAutoSessionTracking` guard in `PreviousSessionFinalizer`,
`MovePreviousSession`, and `InternalSentrySdk.deleteCurrentSessionFile`
prevented finalization of manually started sessions (via `Sentry.startSession()`).

The flag controls *automatic* session lifecycle, not whether sessions exist at all.
Manual sessions write the same files to disk and need the same finalization.

Fixes #5108

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* formatting

* changelog: Add entry for #5154

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                    |  1 +
 .../sentry/android/core/InternalSentrySdk.java  |  8 --------
 .../java/io/sentry/MovePreviousSession.java     |  8 --------
 .../io/sentry/PreviousSessionFinalizer.java     |  7 -------
 .../java/io/sentry/MovePreviousSessionTest.kt   | 16 ++++++++++++----
 .../io/sentry/PreviousSessionFinalizerTest.kt   | 17 +++--------------
 6 files changed, 16 insertions(+), 41 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4da8060b6b2..6e6820a9a43 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Common: Finalize previous session even when auto session tracking is disabled ([#5154](https://github.com/getsentry/sentry-java/pull/5154))
 - Android: Add proguard rules to prevent error about missing Replay classes ([#5153](https://github.com/getsentry/sentry-java/pull/5153))
 
 ## 8.34.0
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/InternalSentrySdk.java b/sentry-android-core/src/main/java/io/sentry/android/core/InternalSentrySdk.java
index cae558f0d43..2779f803a69 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/InternalSentrySdk.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/InternalSentrySdk.java
@@ -1,7 +1,6 @@
 package io.sentry.android.core;
 
 import static io.sentry.Sentry.getCurrentScopes;
-import static io.sentry.SentryLevel.DEBUG;
 import static io.sentry.SentryLevel.INFO;
 import static io.sentry.SentryLevel.WARNING;
 
@@ -291,13 +290,6 @@ private static void deleteCurrentSessionFile(final @NotNull SentryOptions option
       return;
     }
 
-    if (!options.isEnableAutoSessionTracking()) {
-      options
-          .getLogger()
-          .log(DEBUG, "Session tracking is disabled, bailing from deleting current session file.");
-      return;
-    }
-
     final File sessionFile = EnvelopeCache.getCurrentSessionFile(cacheDirPath);
     if (!sessionFile.delete()) {
       options.getLogger().log(WARNING, "Failed to delete the current session file.");
diff --git a/sentry/src/main/java/io/sentry/MovePreviousSession.java b/sentry/src/main/java/io/sentry/MovePreviousSession.java
index 99b92d92653..6b7de16d81a 100644
--- a/sentry/src/main/java/io/sentry/MovePreviousSession.java
+++ b/sentry/src/main/java/io/sentry/MovePreviousSession.java
@@ -1,6 +1,5 @@
 package io.sentry;
 
-import static io.sentry.SentryLevel.DEBUG;
 import static io.sentry.SentryLevel.INFO;
 
 import io.sentry.cache.EnvelopeCache;
@@ -24,13 +23,6 @@ public void run() {
       return;
     }
 
-    if (!options.isEnableAutoSessionTracking()) {
-      options
-          .getLogger()
-          .log(DEBUG, "Session tracking is disabled, bailing from previous session mover.");
-      return;
-    }
-
     final IEnvelopeCache cache = options.getEnvelopeDiskCache();
     if (cache instanceof EnvelopeCache) {
       final File currentSessionFile = EnvelopeCache.getCurrentSessionFile(cacheDirPath);
diff --git a/sentry/src/main/java/io/sentry/PreviousSessionFinalizer.java b/sentry/src/main/java/io/sentry/PreviousSessionFinalizer.java
index 46e0c258507..4e3b2e9b3d2 100644
--- a/sentry/src/main/java/io/sentry/PreviousSessionFinalizer.java
+++ b/sentry/src/main/java/io/sentry/PreviousSessionFinalizer.java
@@ -48,13 +48,6 @@ public void run() {
       return;
     }
 
-    if (!options.isEnableAutoSessionTracking()) {
-      options
-          .getLogger()
-          .log(DEBUG, "Session tracking is disabled, bailing from previous session finalizer.");
-      return;
-    }
-
     final IEnvelopeCache cache = options.getEnvelopeDiskCache();
     if (cache instanceof EnvelopeCache) {
       if (!((EnvelopeCache) cache).waitPreviousSessionFlush()) {
diff --git a/sentry/src/test/java/io/sentry/MovePreviousSessionTest.kt b/sentry/src/test/java/io/sentry/MovePreviousSessionTest.kt
index 0c361c3efe8..f14cbd6d016 100644
--- a/sentry/src/test/java/io/sentry/MovePreviousSessionTest.kt
+++ b/sentry/src/test/java/io/sentry/MovePreviousSessionTest.kt
@@ -65,13 +65,21 @@ class MovePreviousSessionTest {
   }
 
   @Test
-  fun `when session tracking is disabled, logs and returns early`() {
-    val sut = fixture.getSUT(isEnableSessionTracking = false, envelopeCache = fixture.cache)
+  fun `when session tracking is disabled, still moves previous session`() {
+    val sut = fixture.getSUT(isEnableSessionTracking = false)
+
+    val currentSessionFile = EnvelopeCache.getCurrentSessionFile(fixture.options.cacheDirPath!!)
+    val previousSessionFile = EnvelopeCache.getPreviousSessionFile(fixture.options.cacheDirPath!!)
+
+    currentSessionFile.createNewFile()
+    currentSessionFile.writeText("session content")
 
     sut.run()
 
-    verify(fixture.cache, never()).movePreviousSession(any(), any())
-    verify(fixture.cache, never()).flushPreviousSession()
+    (fixture.options.envelopeDiskCache as EnvelopeCache).waitPreviousSessionFlush()
+
+    assertFalse(currentSessionFile.exists())
+    assertTrue(previousSessionFile.exists())
   }
 
   @Test
diff --git a/sentry/src/test/java/io/sentry/PreviousSessionFinalizerTest.kt b/sentry/src/test/java/io/sentry/PreviousSessionFinalizerTest.kt
index 7a205d6d51d..4b433ffb3e1 100644
--- a/sentry/src/test/java/io/sentry/PreviousSessionFinalizerTest.kt
+++ b/sentry/src/test/java/io/sentry/PreviousSessionFinalizerTest.kt
@@ -210,27 +210,16 @@ class PreviousSessionFinalizerTest {
   }
 
   @Test
-  fun `if session tracking is disabled, does not wait for previous session flush`() {
+  fun `if session tracking is disabled, still finalizes previous session`() {
     val finalizer =
       fixture.getSut(
         tmpDir,
-        flushTimeoutMillis = 500L,
+        session = Session(null, null, null, "io.sentry.sample@1.0"),
         sessionTrackingEnabled = false,
-        shouldAwait = true,
       )
     finalizer.run()
 
-    verify(fixture.logger, never())
-      .log(
-        any(),
-        argThat {
-          startsWith(
-            "Timed out waiting to flush previous session to its own file in session finalizer."
-          )
-        },
-        any<Any>(),
-      )
-    verify(fixture.scopes, never()).captureEnvelope(any())
+    verify(fixture.scopes).captureEnvelope(any())
   }
 
   @Test

From 72727477f675aa090fec61bd8a5748fffebfc8b6 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Thu, 5 Mar 2026 15:15:47 +0100
Subject: [PATCH 036/391] chore: Add stacked PR support to create-java-pr skill
 and PR rules (#5151)

* chore: Add stacked PR support to create-java-pr skill and PR rules

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: Use --body-file to avoid shell quoting issues in PR body edits

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .claude/skills/create-java-pr/SKILL.md | 61 +++++++++++++++++++---
 .cursor/rules/pr.mdc                   | 71 +++++++++++++++++---------
 2 files changed, 102 insertions(+), 30 deletions(-)

diff --git a/.claude/skills/create-java-pr/SKILL.md b/.claude/skills/create-java-pr/SKILL.md
index 7dcb5ea47c3..b0fc12a5d2e 100644
--- a/.claude/skills/create-java-pr/SKILL.md
+++ b/.claude/skills/create-java-pr/SKILL.md
@@ -1,12 +1,24 @@
 ---
 name: create-java-pr
-description: Create a pull request in sentry-java. Use when asked to "create pr", "prepare pr", "prep pr", "open pr", "ready for pr", "prepare for review", "finalize changes". Handles branch creation, code formatting, API dump, committing, pushing, PR creation, and changelog.
+description: Create a pull request in sentry-java. Use when asked to "create pr", "prepare pr", "prep pr", "open pr", "ready for pr", "prepare for review", "finalize changes". Handles branch creation, code formatting, API dump, committing, pushing, PR creation, changelog, and stacked PRs.
 ---
 
 # Create Pull Request (sentry-java)
 
 Prepare local changes and create a pull request for the sentry-java repo.
 
+**Required reading:** Before proceeding, read `.cursor/rules/pr.mdc` for the full PR and stacked PR workflow details. That file is the source of truth for PR conventions, stack comment format, branch naming, and merge strategy.
+
+## Step 0: Determine PR Type
+
+Ask the user (or infer from context) whether this is:
+
+- **Standalone PR** — a regular PR targeting `main`. Follow Steps 1–6 as written.
+- **First PR of a new stack** — ask for a topic name (e.g. "Global Attributes"). Create a collection branch from `main`, then branch the first PR off it. The first PR targets the collection branch.
+- **Next PR in an existing stack** — identify the previous stack branch and topic. This PR targets the previous stack branch.
+
+If the user mentions "stack", "stacked PR", or provides a topic name with a number (e.g. `[Topic 2]`), treat it as a stacked PR. See `.cursor/rules/pr.mdc` § "Stacked PRs" for full details.
+
 ## Step 1: Ensure Feature Branch
 
 ```bash
@@ -21,6 +33,8 @@ git checkout -b <type>/<short-description>
 
 Derive the branch name from the changes being made. Use `feat/`, `fix/`, `ref/`, etc. matching the commit type conventions.
 
+**For stacked PRs:** For the first PR in a new stack, first create and push the collection branch (see `.cursor/rules/pr.mdc` § "Creating the Collection Branch"), then branch the PR off it. For subsequent PRs, branch off the previous stack branch. Use the naming conventions from `.cursor/rules/pr.mdc` § "Branch Naming".
+
 ## Step 2: Format Code and Regenerate API Files
 
 ```bash
@@ -92,13 +106,38 @@ Invoke the `sentry-skills:create-pr` skill to create a draft PR. When providing
 
 Fill in each section based on the changes being PR'd. Check any checklist items that apply.
 
-Then continue to Step 6.
+**For stacked PRs:**
+
+- Pass `--base <previous-stack-branch>` so the PR targets the previous branch (first PR in a stack targets the collection branch).
+- Use the stacked PR title format: `<type>(<scope>): [<Topic> <N>] <Subject>` (see `.cursor/rules/pr.mdc` § "PR Title Naming").
+- Include the stack list at the top of the PR body, before the `## :scroll: Description` section (see `.cursor/rules/pr.mdc` § "Stack List in PR Description" for the format).
+
+Then continue to Step 5.5 (stacked PRs only) or Step 6.
+
+## Step 5.5: Update Stack List on All PRs (stacked PRs only)
+
+Skip this step for standalone PRs.
+
+After creating the PR, update the PR description on **every other PR in the stack** so all PRs have the same up-to-date stack list. Follow the format and commands in `.cursor/rules/pr.mdc` § "Stack List in PR Description".
 
 ## Step 6: Update Changelog
 
-After the PR is created, add an entry to `CHANGELOG.md` under the `## Unreleased` section.
+First, determine whether a changelog entry is needed. **Skip this step** (and go straight to "No changelog needed" below) if the changes are not user-facing, for example:
+
+- Test-only changes (new tests, test refactors, test fixtures)
+- CI/CD or build configuration changes
+- Documentation-only changes
+- Code comments or formatting-only changes
+- Internal refactors with no behavior change visible to SDK users
+- Sample app changes
+
+If unsure, ask the user.
+
+### If changelog is needed
+
+Add an entry to `CHANGELOG.md` under the `## Unreleased` section.
 
-### Determine the subsection
+#### Determine the subsection
 
 | Change Type | Subsection |
 |---|---|
@@ -109,7 +148,7 @@ After the PR is created, add an entry to `CHANGELOG.md` under the `## Unreleased
 
 Create the subsection under `## Unreleased` if it does not already exist.
 
-### Entry format
+#### Entry format
 
 ```markdown
 - <Short description of the change> ([#<PR_NUMBER>](https://github.com/getsentry/sentry-java/pull/<PR_NUMBER>))
@@ -117,7 +156,7 @@ Create the subsection under `## Unreleased` if it does not already exist.
 
 Use the PR number returned by `sentry-skills:create-pr`. Match the style of existing entries — sentence case, ending with the PR link, no trailing period.
 
-### Commit and push
+#### Commit and push
 
 Stage `CHANGELOG.md`, commit with message `changelog`, and push:
 
@@ -126,3 +165,13 @@ git add CHANGELOG.md
 git commit -m "changelog"
 git push
 ```
+
+### No changelog needed
+
+If no changelog entry is needed, add `#skip-changelog` to the PR description to disable the changelog CI check:
+
+```bash
+gh pr view <PR_NUMBER> --json body --jq '.body' > /tmp/pr-body.md
+printf '\n#skip-changelog\n' >> /tmp/pr-body.md
+gh pr edit <PR_NUMBER> --body-file /tmp/pr-body.md
+```
diff --git a/.cursor/rules/pr.mdc b/.cursor/rules/pr.mdc
index 581c8cc95d5..3b8f73194b1 100644
--- a/.cursor/rules/pr.mdc
+++ b/.cursor/rules/pr.mdc
@@ -120,21 +120,25 @@ Stacked PRs split a large feature into small, easy-to-review PRs where each buil
 ### Structure
 
 ```
-main → stack-pr-1 → stack-pr-2 → stack-pr-3 → ...
+main ← collection-branch ← stack-pr-1 ← stack-pr-2 ← stack-pr-3 ← ...
 ```
 
-- The first PR in the stack targets `main` as its base branch.
+- A **collection branch** is created from `main` and targets `main`. It serves as the base for the entire stack.
+- The first PR in the stack targets the collection branch (not `main`).
 - Each subsequent PR targets the previous stack PR's branch as its base.
 - Each PR contains only incremental changes on top of the previous one.
 
+The collection branch exists so that individual stack PRs can be **merge-committed** (not squashed). PRs targeting `main` use squash merging, but that causes repeated merge conflicts when syncing the stack. Merge commits on non-`main` branches avoid this. The collection branch itself is squash-merged into `main` at the end.
+
 ### Branch Naming
 
-Prefer a shared prefix for the feature, with descriptive suffixes per PR. The type prefix (`feat/`, `fix/`, etc.) may vary depending on the nature of each PR's changes:
+Prefer a shared prefix for the feature, with descriptive suffixes per PR. The collection branch uses the shared prefix. The type prefix (`feat/`, `fix/`, etc.) may vary depending on the nature of each PR's changes:
 
 ```
-feat/scope-attributes              # PR 1
-feat/scope-attributes-logger       # PR 2
-fix/attribute-type-detection        # PR 3 (fix, different name — that's fine)
+feat/scope-attributes              # collection branch → targets main
+feat/scope-attributes-api          # PR 1 → targets collection branch
+feat/scope-attributes-logger       # PR 2 → targets PR 1
+fix/attribute-type-detection        # PR 3 (fix, different name — that's fine) → targets PR 2
 ```
 
 ### PR Title Naming
@@ -158,8 +162,8 @@ Do **not** rely on branch name patterns — later PRs in a stack may use differe
    ```bash
    gh pr list --head "$(git branch --show-current)" --json number,title,baseRefName --jq '.[0]'
    ```
-2. Read the stack comment on that PR — it lists every PR in the stack.
-3. If there is no stack comment yet, walk the chain in both directions:
+2. Read the PR description — the stack list is at the top of the body.
+3. If there is no stack list yet, walk the chain in both directions:
    ```bash
    # Find the PR whose head branch is the current PR's base (go up)
    gh pr list --head <baseRefName> --json number,title,baseRefName
@@ -167,21 +171,33 @@ Do **not** rely on branch name patterns — later PRs in a stack may use differe
    # Find PRs whose base branch is the current PR's head (go down)
    gh pr list --base <currentBranch> --json number,title,headRefName
    ```
-   Repeat until you reach `main` going up and find no more PRs going down.
+   Repeat until you reach the collection branch going up and find no more PRs going down.
+
+### Creating the Collection Branch
+
+Before the first stacked PR, create the collection branch with an empty commit (so GitHub allows opening a PR) and create the collection PR:
+
+```bash
+git checkout main
+git checkout -b feat/<topic>
+git commit --allow-empty -m "collection: <topic>"
+git push -u origin HEAD
+gh pr create --base main --draft --title "<type>(<scope>): <Topic>" --body "Collection PR for the <Topic> stack. Squash-merge this once all stack PRs are merged."
+```
 
 ### Creating a New Stacked PR
 
-1. Start from the tip of the previous stack branch (or `main` for the first PR).
+1. Start from the tip of the previous stack branch (or the collection branch for the first PR).
 2. Create a new branch, make changes, format, commit, and push.
-3. Create the PR with `--base <previous-branch>`:
+3. Create the PR with `--base <previous-branch>` (the collection branch for the first PR):
    ```bash
    gh pr create --base feat/previous-branch --draft --title "<type>(<scope>): [<Topic> <N>] <Subject>" --body "..."
    ```
-4. Add the stack comment to the new PR and update it on all existing PRs in the stack (see below).
+4. Add the stack list to the top of the new PR's description and update it on all existing PRs in the stack (see below).
 
-### Stack Comment
+### Stack List in PR Description
 
-Every PR in the stack must have a comment listing all PRs in the stack. When a new PR is added, update the comment on **all** PRs in the stack.
+Every PR in the stack must have a stack list **at the top of its description** (before the `## :scroll: Description` section). When a new PR is added, update the description on **all** PRs in the stack.
 
 Format:
 
@@ -191,26 +207,33 @@ Format:
 - [#5118](https://github.com/getsentry/sentry-java/pull/5118) — Add scope-level attributes API
 - [#5120](https://github.com/getsentry/sentry-java/pull/5120) — Wire scope attributes into LoggerApi and MetricsApi
 - [#5121](https://github.com/getsentry/sentry-java/pull/5121) — Showcase scope attributes in Spring Boot 4 samples
+
+---
 ```
 
-No status column — GitHub already shows that.
+No status column — GitHub already shows that. The `---` separates the stack list from the rest of the PR description.
 
-To add or update the stack comment on a PR:
+To update the PR description, use `--body-file` to avoid shell quoting issues with special characters in the body:
 
 ```bash
-# Find existing stack comment (if any)
-gh api repos/getsentry/sentry-java/issues/<PR_NUMBER>/comments --jq '.[] | select(.body | startswith("## PR Stack")) | .id'
+# Get current PR description into a temp file
+gh pr view <PR_NUMBER> --json body --jq '.body' > /tmp/pr-body.md
 
-# Create new comment
-gh pr comment <PR_NUMBER> --body "<stack comment body>"
+# Edit /tmp/pr-body.md to prepend or replace the stack list section
+# (replace everything from "## PR Stack" up to and including the "---" separator,
+#  or prepend before the existing description if no stack list exists yet)
 
-# Or update existing comment
-gh api repos/getsentry/sentry-java/issues/comments/<COMMENT_ID> -X PATCH -f body="<stack comment body>"
+# Update the description
+gh pr edit <PR_NUMBER> --body-file /tmp/pr-body.md
 ```
 
-### Merging Stacked PRs
+### Merging Stacked PRs (done by the user, not the agent)
+
+Individual stack PRs are merged in order from bottom to top (PR 1 first, then PR 2, etc.) using **merge commits** (not squash). After each merge, the next PR's base automatically becomes the merged branch's target. GitHub handles rebasing onto the new base.
+
+Once all stack PRs are merged into the collection branch, the collection PR is **squash-merged** into `main`. This gives `main` a clean single commit for the entire feature.
 
-Merge in order from bottom to top (PR 1 first, then PR 2, etc.). After each merge, the next PR's base automatically becomes the merged branch's target. GitHub handles rebasing onto the new base. Verify each PR's diff still looks correct after the previous one merges.
+**Do not merge PRs.** Only the user merges PRs.
 
 ### Syncing the Stack
 

From 20ec62ae22edbbcdbb4aa67cccde8368704a63cb Mon Sep 17 00:00:00 2001
From: Abhishek Singh <45100807+abhishek-900@users.noreply.github.com>
Date: Thu, 5 Mar 2026 20:35:02 +0530
Subject: [PATCH 037/391] fix(android): Add filterTouchesWhenObscured to
 prevent Tapjacking (#5155)

* fix(android): Add filterTouchesWhenObscured to prevent Tapjacking

Adds  filterTouchesWhenObscured="true" to the user feedback dialog to prevent overlay/tapjacking attack ( CWE-1021)

* Changelog

---------

Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 CHANGELOG.md                                                     | 1 +
 .../src/main/res/layout/sentry_dialog_user_feedback.xml          | 1 +
 2 files changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6e6820a9a43..583151c1faa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Fixes
 
 - Common: Finalize previous session even when auto session tracking is disabled ([#5154](https://github.com/getsentry/sentry-java/pull/5154))
+- Android: Add `filterTouchesWhenObscured` to prevent Tapjacking on user feedback dialog ([#5155](https://github.com/getsentry/sentry-java/pull/5155))
 - Android: Add proguard rules to prevent error about missing Replay classes ([#5153](https://github.com/getsentry/sentry-java/pull/5153))
 
 ## 8.34.0
diff --git a/sentry-android-core/src/main/res/layout/sentry_dialog_user_feedback.xml b/sentry-android-core/src/main/res/layout/sentry_dialog_user_feedback.xml
index e6f77b90a7f..722a0d5cf3d 100644
--- a/sentry-android-core/src/main/res/layout/sentry_dialog_user_feedback.xml
+++ b/sentry-android-core/src/main/res/layout/sentry_dialog_user_feedback.xml
@@ -4,6 +4,7 @@
     android:id="@+id/sentry_dialog_user_feedback_layout"
     android:layout_width="match_parent"
     android:layout_height="match_parent"
+    android:filterTouchesWhenObscured="true"
     tools:ignore="HardcodedText,RtlHardcoded"
     android:theme="?android:attr/dialogTheme"
     android:padding="24dp">

From f063350b14bb573ff877263215731686481e30c6 Mon Sep 17 00:00:00 2001
From: romtsn <4999776+romtsn@users.noreply.github.com>
Date: Thu, 5 Mar 2026 15:06:09 +0000
Subject: [PATCH 038/391] release: 8.34.1

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 583151c1faa..e032293263e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.34.1
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index 9c919a6bde2..db7fab6765c 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.9.0
 
 # Release information
-versionName=8.34.0
+versionName=8.34.1
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From d501a7eb9c9ddbb1bc297984c6d7b7aaef1b2359 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Fri, 6 Mar 2026 11:19:23 +0100
Subject: [PATCH 039/391] feat(anr): Profile main thread when ANR and report
 ANR profiles to Sentry (#4899)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Profile main thread when ANR and report ANR profiles to sentry

* docs(changelog): Add ANR profiling integration entry

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Fix api dump file

* Address PR feedback

* refactor(anr): Implement lazy file rotation for ANR profiling

* Update Changelog

* Address PR feedback

* Improve folding logic, cleanup tests

* Add more tests and address feedback

* Update CHANGELOG.md

* Address PR feedcback

* Move logic to event processor

* Update changelog

* Ensure integration is tracked

* Address PR feedback

* Fix tests

* Match manifest property to convention, enable profiling in sample app

* Add more bound checks and null guards

* Remove outdated meta-data

* Properly handle foreground transitions

* Address PR comments

* Address PR feedback

* Address PR feedback

* Address PR feedback

* Re-use thread

* Update Changelop

* Address review

* Address PR feedback

* Replace ANR profiling boolean flag with sample-rate (#5156)

* feat(android): Add enableAnrFingerprinting option (#5168)

* feat(android): Add enableAnrFingerprinting option

Decouple ANR fingerprinting from ANR profiling into a standalone
opt-in option. This allows static fingerprinting of system-frame-only
ANRs regardless of whether profiling is enabled.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(android): Mark enableAnrFingerprinting as experimental

Also enable the option in the sample app.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(android): Default enableAnrFingerprinting to true

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* refactor(android): Remove experimental flag from enableAnrFingerprinting

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix api dump

* Address PR feedback

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

* Fix tests

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 CHANGELOG.md                                  |  10 +-
 .../api/sentry-android-core.api               |  78 +++++
 .../core/AndroidOptionsInitializer.java       |   6 +
 .../sentry/android/core/AnrIntegration.java   |  11 +-
 .../ApplicationExitInfoEventProcessor.java    | 175 +++++++++-
 .../core/ApplicationNotResponding.java        |   9 +-
 .../android/core/ManifestMetadataReader.java  |  16 +
 .../android/core/SentryAndroidOptions.java    |  46 +++
 .../core/anr/AggregatedStackTrace.java        |  56 ++++
 .../core/anr/AnrCulpritIdentifier.java        | 165 +++++++++
 .../sentry/android/core/anr/AnrProfile.java   |  35 ++
 .../android/core/anr/AnrProfileManager.java   | 103 ++++++
 .../core/anr/AnrProfileRotationHelper.java    |  73 ++++
 .../core/anr/AnrProfilingIntegration.java     | 308 +++++++++++++++++
 .../android/core/anr/AnrStackTrace.java       |  79 +++++
 .../android/core/anr/StackTraceConverter.java | 150 +++++++++
 .../io/sentry/android/core/ANRWatchDogTest.kt |   8 +-
 .../android/core/AnrV2IntegrationTest.kt      |  29 ++
 .../ApplicationExitInfoEventProcessorTest.kt  | 218 +++++++++++-
 .../ApplicationExitIntegrationTestBase.kt     |   1 +
 .../core/ManifestMetadataReaderTest.kt        |  50 +++
 .../android/core/SentryAndroidOptionsTest.kt  |  38 +++
 .../sentry/android/core/SentryAndroidTest.kt  |   4 +-
 .../core/anr/AnrCulpritIdentifierTest.kt      | 167 ++++++++++
 .../android/core/anr/AnrProfileManagerTest.kt | 137 ++++++++
 .../core/anr/AnrProfileRotationHelperTest.kt  | 113 +++++++
 .../core/anr/AnrProfilingIntegrationTest.kt   | 313 ++++++++++++++++++
 .../core/anr/AnrStackTraceConverterTest.kt    | 197 +++++++++++
 .../android/core/anr/AnrStackTraceTest.kt     | 127 +++++++
 .../distribution/UpdateResponseParserTest.kt  |   4 +-
 .../src/main/AndroidManifest.xml              |   8 +-
 sentry/api/sentry.api                         |   1 +
 .../src/main/java/io/sentry/ProfileChunk.java |   8 +-
 .../java/io/sentry/SentryEnvelopeItem.java    |  64 ++--
 .../io/sentry/SentryExceptionFactory.java     |   4 +-
 .../ExceptionMechanismException.java          |  11 +-
 .../main/java/io/sentry/util/StringUtils.java |   8 +
 37 files changed, 2772 insertions(+), 58 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/anr/AggregatedStackTrace.java
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrCulpritIdentifier.java
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfile.java
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfileManager.java
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfileRotationHelper.java
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfilingIntegration.java
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrStackTrace.java
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/anr/StackTraceConverter.java
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrCulpritIdentifierTest.kt
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfileManagerTest.kt
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfileRotationHelperTest.kt
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceConverterTest.kt
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e032293263e..503d58a4eda 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -45,6 +45,14 @@
     <meta-data android:name="io.sentry.screenshot.mask-all-images" android:value="true" />
     ```
 - The `ManifestMetaDataReader` now read the `DIST` ([#5107](https://github.com/getsentry/sentry-java/pull/5107))
+- Add new experimental option to capture profiles for ANRs ([#4899](https://github.com/getsentry/sentry-java/pull/4899))
+  - This feature will capture a stack profile of the main thread when it gets unresponsive
+  - The profile gets attached to the ANR event on the next app start, providing a flamegraph of the ANR issue on the sentry issue details page
+  - Enable via `options.setAnrProfilingSampleRate(<sample-rate>)` or AndroidManifest.xml: `<meta-data android:name="io.sentry.anr.profiling.sample-rate" android:value="[0.0-1.0]" />`
+  - The sample rate controls the probability of collecting a profile for each detected foreground ANR (0.0 to 1.0, null to disable)
+- Add `enableAnrFingerprinting` option to reduce ANR noise by assigning static fingerprints to ANR events with system-only stacktraces
+  - When enabled, ANRs whose stacktraces contain only system frames (e.g. `java.lang` or `android.os`) are grouped into a single issue instead of creating many separate issues
+  - Enable via `options.setEnableAnrFingerprinting(true)` or AndroidManifest.xml: `<meta-data android:name="io.sentry.anr.enable-fingerprinting" android:value="true" />`
 
 ### Fixes
 
@@ -180,7 +188,7 @@
 - Discard envelopes on `4xx` and `5xx` response ([#4950](https://github.com/getsentry/sentry-java/pull/4950))
   - This aims to not overwhelm Sentry after an outage or load shedding (including HTTP 429) where too many events are sent at once
 
-### Feature
+### Features
 
 - Add a Tombstone integration that detects native crashes without relying on the NDK integration, but instead using `ApplicationExitInfo.REASON_CRASH_NATIVE` on Android 12+. ([#4933](https://github.com/getsentry/sentry-java/pull/4933))
   - Currently exposed via options as an _internal_ API only.
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 7e64d0bcf80..4e7e7b4c5c2 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -347,6 +347,7 @@ public final class io/sentry/android/core/SentryAndroidDateProvider : io/sentry/
 public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/SentryOptions {
 	public fun <init> ()V
 	public fun enableAllAutoBreadcrumbs (Z)V
+	public fun getAnrProfilingSampleRate ()Ljava/lang/Double;
 	public fun getAnrTimeoutIntervalMillis ()J
 	public fun getBeforeScreenshotCaptureCallback ()Lio/sentry/android/core/SentryAndroidOptions$BeforeCaptureCallback;
 	public fun getBeforeViewHierarchyCaptureCallback ()Lio/sentry/android/core/SentryAndroidOptions$BeforeCaptureCallback;
@@ -357,6 +358,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun getScreenshot ()Lio/sentry/android/core/SentryScreenshotOptions;
 	public fun getStartupCrashDurationThresholdMillis ()J
 	public fun isAnrEnabled ()Z
+	public fun isAnrProfilingEnabled ()Z
 	public fun isAnrReportInDebug ()Z
 	public fun isAttachAnrThreadDump ()Z
 	public fun isAttachScreenshot ()Z
@@ -365,6 +367,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun isCollectExternalStorageContext ()Z
 	public fun isEnableActivityLifecycleBreadcrumbs ()Z
 	public fun isEnableActivityLifecycleTracingAutoFinish ()Z
+	public fun isEnableAnrFingerprinting ()Z
 	public fun isEnableAppComponentBreadcrumbs ()Z
 	public fun isEnableAppLifecycleBreadcrumbs ()Z
 	public fun isEnableAutoActivityLifecycleTracing ()Z
@@ -381,6 +384,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun isReportHistoricalTombstones ()Z
 	public fun isTombstoneEnabled ()Z
 	public fun setAnrEnabled (Z)V
+	public fun setAnrProfilingSampleRate (Ljava/lang/Double;)V
 	public fun setAnrReportInDebug (Z)V
 	public fun setAnrTimeoutIntervalMillis (J)V
 	public fun setAttachAnrThreadDump (Z)V
@@ -393,6 +397,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun setDebugImagesLoader (Lio/sentry/android/core/IDebugImagesLoader;)V
 	public fun setEnableActivityLifecycleBreadcrumbs (Z)V
 	public fun setEnableActivityLifecycleTracingAutoFinish (Z)V
+	public fun setEnableAnrFingerprinting (Z)V
 	public fun setEnableAppComponentBreadcrumbs (Z)V
 	public fun setEnableAppLifecycleBreadcrumbs (Z)V
 	public fun setEnableAutoActivityLifecycleTracing (Z)V
@@ -553,6 +558,79 @@ public final class io/sentry/android/core/ViewHierarchyEventProcessor : io/sentr
 	public static fun snapshotViewHierarchyAsData (Landroid/app/Activity;Lio/sentry/util/thread/IThreadChecker;Lio/sentry/ISerializer;Lio/sentry/ILogger;)[B
 }
 
+public class io/sentry/android/core/anr/AggregatedStackTrace {
+	public fun <init> ([Ljava/lang/StackTraceElement;IIJF)V
+	public fun addOccurrence (J)V
+	public fun getStack ()[Ljava/lang/StackTraceElement;
+}
+
+public class io/sentry/android/core/anr/AnrCulpritIdentifier {
+	public fun <init> ()V
+	public static fun identify (Ljava/util/List;)Lio/sentry/android/core/anr/AggregatedStackTrace;
+	public static fun isSystemFrame (Ljava/lang/String;)Z
+}
+
+public class io/sentry/android/core/anr/AnrProfile {
+	public final field endTimeMs J
+	public final field stacks Ljava/util/List;
+	public final field startTimeMs J
+	public fun <init> (Ljava/util/List;)V
+}
+
+public class io/sentry/android/core/anr/AnrProfileManager : java/lang/AutoCloseable {
+	public fun <init> (Lio/sentry/SentryOptions;)V
+	public fun <init> (Lio/sentry/SentryOptions;Ljava/io/File;)V
+	public fun add (Lio/sentry/android/core/anr/AnrStackTrace;)V
+	public fun clear ()V
+	public fun close ()V
+	public fun load ()Lio/sentry/android/core/anr/AnrProfile;
+}
+
+public class io/sentry/android/core/anr/AnrProfileRotationHelper {
+	public fun <init> ()V
+	public static fun deleteLastFile (Ljava/io/File;)Z
+	public static fun getFileForRecording (Ljava/io/File;)Ljava/io/File;
+	public static fun getLastFile (Ljava/io/File;)Ljava/io/File;
+	public static fun rotate ()V
+}
+
+public class io/sentry/android/core/anr/AnrProfilingIntegration : io/sentry/Integration, io/sentry/android/core/AppState$AppStateListener, java/io/Closeable, java/lang/Runnable {
+	public static final field POLLING_INTERVAL_MS J
+	public static final field THRESHOLD_ANR_MS J
+	public fun <init> ()V
+	protected fun checkMainThread (Ljava/lang/Thread;)V
+	public fun close ()V
+	protected fun getProfileManager ()Lio/sentry/android/core/anr/AnrProfileManager;
+	protected fun getState ()Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public fun onBackground ()V
+	public fun onForeground ()V
+	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
+	public fun run ()V
+}
+
+protected final class io/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState : java/lang/Enum {
+	public static final field ANR_DETECTED Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public static final field IDLE Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public static final field SUSPICIOUS Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public static fun valueOf (Ljava/lang/String;)Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+	public static fun values ()[Lio/sentry/android/core/anr/AnrProfilingIntegration$MainThreadState;
+}
+
+public final class io/sentry/android/core/anr/AnrStackTrace : java/lang/Comparable {
+	public final field stack [Ljava/lang/StackTraceElement;
+	public final field timestampMs J
+	public fun <init> (J[Ljava/lang/StackTraceElement;)V
+	public fun compareTo (Lio/sentry/android/core/anr/AnrStackTrace;)I
+	public synthetic fun compareTo (Ljava/lang/Object;)I
+	public static fun deserialize (Ljava/io/DataInputStream;)Lio/sentry/android/core/anr/AnrStackTrace;
+	public fun serialize (Ljava/io/DataOutputStream;)V
+}
+
+public final class io/sentry/android/core/anr/StackTraceConverter {
+	public fun <init> ()V
+	public static fun convert (Lio/sentry/android/core/anr/AnrProfile;)Lio/sentry/protocol/profiling/SentryProfile;
+}
+
 public final class io/sentry/android/core/cache/AndroidEnvelopeCache : io/sentry/cache/EnvelopeCache {
 	public static final field LAST_ANR_MARKER_LABEL Ljava/lang/String;
 	public static final field LAST_ANR_REPORT Ljava/lang/String;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index a189b30d07b..f83960a3e6b 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -26,6 +26,8 @@
 import io.sentry.SendFireAndForgetOutboxSender;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOpenTelemetryMode;
+import io.sentry.android.core.anr.AnrProfileRotationHelper;
+import io.sentry.android.core.anr.AnrProfilingIntegration;
 import io.sentry.android.core.cache.AndroidEnvelopeCache;
 import io.sentry.android.core.internal.debugmeta.AssetsDebugMetaLoader;
 import io.sentry.android.core.internal.gestures.AndroidViewGestureTargetLocator;
@@ -135,6 +137,8 @@ static void loadDefaultAndMetadataOptions(
 
     options.setCacheDirPath(getCacheDir(finalContext).getAbsolutePath());
 
+    AnrProfileRotationHelper.rotate();
+
     readDefaultOptionValues(options, finalContext, buildInfoProvider);
     AppState.getInstance().registerLifecycleObserver(options);
     options.activate();
@@ -397,6 +401,8 @@ static void installDefaultIntegrations(
     // it to set the replayId in case of an ANR
     options.addIntegration(AnrIntegrationFactory.create(context, buildInfoProvider));
 
+    options.addIntegration(new AnrProfilingIntegration());
+
     // registerActivityLifecycleCallbacks is only available if Context is an AppContext
     if (context instanceof Application) {
       options.addIntegration(
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AnrIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/AnrIntegration.java
index 8243493a50b..f37d433d308 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AnrIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AnrIntegration.java
@@ -139,11 +139,18 @@ void reportANR(
       message = "Background " + message;
     }
 
-    final ApplicationNotResponding error = new ApplicationNotResponding(message, anr.getThread());
+    final @Nullable Thread thread = anr.getThread();
+    final @NotNull ApplicationNotResponding error;
+    if (thread == null) {
+      error = new ApplicationNotResponding(message);
+    } else {
+      error = new ApplicationNotResponding(message, thread);
+    }
+
     final Mechanism mechanism = new Mechanism();
     mechanism.setType("ANR");
 
-    return new ExceptionMechanismException(mechanism, error, error.getThread(), true);
+    return new ExceptionMechanismException(mechanism, error, thread, true);
   }
 
   @TestOnly
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
index 58d0a5a59d7..2eca0e68b5b 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
@@ -29,6 +29,9 @@
 import io.sentry.Breadcrumb;
 import io.sentry.Hint;
 import io.sentry.IpAddressUtils;
+import io.sentry.ProfileChunk;
+import io.sentry.ProfileContext;
+import io.sentry.Sentry;
 import io.sentry.SentryBaseEvent;
 import io.sentry.SentryEvent;
 import io.sentry.SentryExceptionFactory;
@@ -36,9 +39,16 @@
 import io.sentry.SentryOptions;
 import io.sentry.SentryStackTraceFactory;
 import io.sentry.SpanContext;
+import io.sentry.android.core.anr.AggregatedStackTrace;
+import io.sentry.android.core.anr.AnrCulpritIdentifier;
+import io.sentry.android.core.anr.AnrProfile;
+import io.sentry.android.core.anr.AnrProfileManager;
+import io.sentry.android.core.anr.AnrProfileRotationHelper;
+import io.sentry.android.core.anr.StackTraceConverter;
 import io.sentry.android.core.internal.util.CpuInfoUtils;
 import io.sentry.cache.PersistingOptionsObserver;
 import io.sentry.cache.PersistingScopeObserver;
+import io.sentry.exception.ExceptionMechanismException;
 import io.sentry.hints.AbnormalExit;
 import io.sentry.hints.Backfillable;
 import io.sentry.protocol.App;
@@ -50,10 +60,14 @@
 import io.sentry.protocol.OperatingSystem;
 import io.sentry.protocol.Request;
 import io.sentry.protocol.SdkVersion;
+import io.sentry.protocol.SentryException;
+import io.sentry.protocol.SentryId;
+import io.sentry.protocol.SentryStackFrame;
 import io.sentry.protocol.SentryStackTrace;
 import io.sentry.protocol.SentryThread;
 import io.sentry.protocol.SentryTransaction;
 import io.sentry.protocol.User;
+import io.sentry.protocol.profiling.SentryProfile;
 import io.sentry.util.HintUtils;
 import io.sentry.util.SentryRandom;
 import java.io.File;
@@ -700,8 +714,15 @@ public void applyPreEnrichment(
     public void applyPostEnrichment(
         @NotNull SentryEvent event, @NotNull Backfillable hint, @NotNull Object rawHint) {
       final boolean isBackgroundAnr = isBackgroundAnr(rawHint);
-      setAppForeground(event, !isBackgroundAnr);
+
+      if (options.isAnrProfilingEnabled()) {
+        applyAnrProfile(event, hint, isBackgroundAnr);
+      }
+
       setDefaultAnrFingerprint(event, isBackgroundAnr);
+
+      // Set app foreground state
+      setAppForeground(event, !isBackgroundAnr);
     }
 
     private void setDefaultAnrFingerprint(
@@ -709,7 +730,17 @@ private void setDefaultAnrFingerprint(
       // sentry does not yet have a capability to provide default server-side fingerprint rules,
       // so we're doing this on the SDK side to group background and foreground ANRs separately
       // even if they have similar stacktraces.
-      if (event.getFingerprints() == null) {
+      if (event.getFingerprints() != null) {
+        return;
+      }
+
+      if (options.isEnableAnrFingerprinting() && hasOnlySystemFrames(event)) {
+        // If the stacktrace only contains system frames, we want to statically group these events
+        // to avoid ANR noise due to {{ default }} stacktrace grouping
+        event.setFingerprints(
+            Arrays.asList(
+                "system-frames-only-anr", isBackgroundAnr ? "background-anr" : "foreground-anr"));
+      } else {
         event.setFingerprints(
             Arrays.asList("{{ default }}", isBackgroundAnr ? "background-anr" : "foreground-anr"));
       }
@@ -777,5 +808,145 @@ private void setAnrExceptions(
       event.setExceptions(
           sentryExceptionFactory.getSentryExceptionsFromThread(mainThread, mechanism, anr));
     }
+
+    private void applyAnrProfile(
+        @NotNull SentryEvent event, @NotNull Backfillable hint, boolean isBackgroundAnr) {
+
+      // Skip background ANRs (as profiling only runs in foreground)
+      if (isBackgroundAnr) {
+        return;
+      }
+
+      final String cacheDirPath = options.getCacheDirPath();
+      if (cacheDirPath == null) {
+        return;
+      }
+      final File cacheDir = new File(cacheDirPath);
+
+      if (!(hint instanceof AbnormalExit)) {
+        return;
+      }
+      final Long anrTimestampObj = ((AbnormalExit) hint).timestamp();
+      final long anrTimestamp;
+      if (anrTimestampObj != null) {
+        anrTimestamp = anrTimestampObj;
+      } else if (event.getTimestamp() != null) {
+        anrTimestamp = event.getTimestamp().getTime();
+      } else {
+        return;
+      }
+
+      AnrProfile anrProfile = null;
+      try {
+        final File lastFile = AnrProfileRotationHelper.getLastFile(cacheDir);
+        if (lastFile.exists()) {
+          options.getLogger().log(SentryLevel.DEBUG, "Reading ANR profile");
+          try (final AnrProfileManager provider = new AnrProfileManager(options, lastFile)) {
+            anrProfile = provider.load();
+          }
+        } else {
+          options.getLogger().log(SentryLevel.DEBUG, "No ANR profile file found");
+        }
+      } catch (Throwable t) {
+        options.getLogger().log(SentryLevel.INFO, "Could not retrieve ANR profile", t);
+      } finally {
+        if (!AnrProfileRotationHelper.deleteLastFile(cacheDir)) {
+          options.getLogger().log(SentryLevel.INFO, "Could not delete ANR profile file");
+        }
+      }
+
+      if (anrProfile == null) {
+        return;
+      }
+
+      options.getLogger().log(SentryLevel.INFO, "ANR profile found");
+      if (anrTimestamp < anrProfile.startTimeMs || anrTimestamp > anrProfile.endTimeMs) {
+        options.getLogger().log(SentryLevel.DEBUG, "ANR profile found, but doesn't match");
+        return;
+      }
+
+      final AggregatedStackTrace culprit = AnrCulpritIdentifier.identify(anrProfile.stacks);
+      if (culprit == null) {
+        return;
+      }
+
+      // Capture profile chunk
+      final @Nullable SentryId profilerId = captureAnrProfile(anrTimestamp, anrProfile);
+      final @NotNull StackTraceElement[] stack = culprit.getStack();
+
+      if (stack.length > 0) {
+        final StackTraceElement stackTraceElement = stack[0];
+        final String message =
+            stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName();
+        final ApplicationNotResponding exception = new ApplicationNotResponding(message);
+        exception.setStackTrace(stack);
+
+        final Mechanism mechanism = new Mechanism();
+        mechanism.setType("ANR");
+        final ExceptionMechanismException error =
+            new ExceptionMechanismException(mechanism, exception, null, false);
+
+        final @NotNull List<SentryException> sentryException =
+            sentryExceptionFactory.getSentryExceptions(error);
+
+        // Replace the original ANR exception with the profile-derived one,
+        // as we assume the profiling culprit identification is more valuable
+        // the event threads are kept as-is, so the original main thread stacktrace is still
+        // available
+        event.setExceptions(sentryException);
+
+        if (profilerId != null) {
+          event.getContexts().setProfile(new ProfileContext(profilerId));
+        }
+      }
+    }
+
+    @Nullable
+    private SentryId captureAnrProfile(final long anrTimestampMs, @NotNull AnrProfile anrProfile) {
+      final SentryProfile profile = StackTraceConverter.convert(anrProfile);
+      final ProfileChunk chunk =
+          new ProfileChunk(
+              new SentryId(),
+              new SentryId(),
+              null,
+              new HashMap<>(0),
+              anrTimestampMs / 1000.0d,
+              ProfileChunk.PLATFORM_JAVA,
+              options);
+      chunk.setSentryProfile(profile);
+
+      final SentryId profilerId = Sentry.getCurrentScopes().captureProfileChunk(chunk);
+      if (SentryId.EMPTY_ID.equals(profilerId)) {
+        return null;
+      } else {
+        return chunk.getProfilerId();
+      }
+    }
+
+    private boolean hasOnlySystemFrames(@NotNull SentryEvent event) {
+      final List<SentryException> exceptions = event.getExceptions();
+      if (exceptions == null || exceptions.isEmpty()) {
+        return false;
+      }
+
+      for (final SentryException exception : exceptions) {
+        final SentryStackTrace stacktrace = exception.getStacktrace();
+        if (stacktrace != null) {
+          final List<SentryStackFrame> frames = stacktrace.getFrames();
+          if (frames != null && !frames.isEmpty()) {
+            for (final SentryStackFrame frame : frames) {
+              if (frame.isInApp() != null && frame.isInApp()) {
+                return false;
+              }
+              final String module = frame.getModule();
+              if (module != null && !AnrCulpritIdentifier.isSystemFrame(module)) {
+                return false;
+              }
+            }
+          }
+        }
+      }
+      return true;
+    }
   }
 }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationNotResponding.java b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationNotResponding.java
index f4998240f81..7b21c2e392c 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationNotResponding.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationNotResponding.java
@@ -17,7 +17,12 @@
 final class ApplicationNotResponding extends RuntimeException {
   private static final long serialVersionUID = 252541144579117016L;
 
-  private final @NotNull Thread thread;
+  private final @Nullable Thread thread;
+
+  ApplicationNotResponding(final @Nullable String message) {
+    super(message);
+    this.thread = null;
+  }
 
   ApplicationNotResponding(final @Nullable String message, final @NotNull Thread thread) {
     super(message);
@@ -25,7 +30,7 @@ final class ApplicationNotResponding extends RuntimeException {
     setStackTrace(this.thread.getStackTrace());
   }
 
-  public @NotNull Thread getThread() {
+  public @Nullable Thread getThread() {
     return thread;
   }
 }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 0fd217794e2..940fe8f4362 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -175,6 +175,10 @@ final class ManifestMetadataReader {
 
   static final String SCREENSHOT_MASK_ALL_IMAGES = "io.sentry.screenshot.mask-all-images";
 
+  static final String ANR_PROFILING_SAMPLE_RATE = "io.sentry.anr.profiling.sample-rate";
+
+  static final String ENABLE_ANR_FINGERPRINTING = "io.sentry.anr.enable-fingerprinting";
+
   /** ManifestMetadataReader ctor */
   private ManifestMetadataReader() {}
 
@@ -674,6 +678,18 @@ static void applyMetadata(
         options
             .getScreenshot()
             .setMaskAllImages(readBool(metadata, logger, SCREENSHOT_MASK_ALL_IMAGES, false));
+
+        if (options.getAnrProfilingSampleRate() == null) {
+          final double anrProfilingSampleRate =
+              readDouble(metadata, logger, ANR_PROFILING_SAMPLE_RATE);
+          if (anrProfilingSampleRate != -1) {
+            options.setAnrProfilingSampleRate(anrProfilingSampleRate);
+          }
+        }
+
+        options.setEnableAnrFingerprinting(
+            readBool(
+                metadata, logger, ENABLE_ANR_FINGERPRINTING, options.isEnableAnrFingerprinting()));
       }
       options
           .getLogger()
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
index 9630fd59618..054e43322a2 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
@@ -17,6 +17,7 @@
 import io.sentry.protocol.Mechanism;
 import io.sentry.protocol.SdkVersion;
 import io.sentry.protocol.SentryId;
+import io.sentry.util.SampleRateUtils;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -252,6 +253,10 @@ public interface BeforeCaptureCallback {
    */
   private final @NotNull SentryScreenshotOptions screenshot = new SentryScreenshotOptions();
 
+  private @Nullable Double anrProfilingSampleRate;
+
+  private boolean enableAnrFingerprinting = true;
+
   public SentryAndroidOptions() {
     setSentryClientName(BuildConfig.SENTRY_ANDROID_SDK_NAME + "/" + BuildConfig.VERSION_NAME);
     setSdkVersion(createSdkVersion());
@@ -695,6 +700,47 @@ public void setEnableSystemEventBreadcrumbsExtras(
     return screenshot;
   }
 
+  public @Nullable Double getAnrProfilingSampleRate() {
+    return anrProfilingSampleRate;
+  }
+
+  public void setAnrProfilingSampleRate(final @Nullable Double anrProfilingSampleRate) {
+    if (!SampleRateUtils.isValidSampleRate(anrProfilingSampleRate)) {
+      throw new IllegalArgumentException(
+          "The value "
+              + anrProfilingSampleRate
+              + " is not valid. Use null to disable or values >= 0.0 and <= 1.0.");
+    }
+    this.anrProfilingSampleRate = anrProfilingSampleRate;
+  }
+
+  public boolean isAnrProfilingEnabled() {
+    return anrProfilingSampleRate != null && anrProfilingSampleRate > 0;
+  }
+
+  /**
+   * Returns whether ANR fingerprinting is enabled. When enabled, the SDK assigns static
+   * fingerprints to ANR events that would otherwise produce noisy grouping. Currently, this applies
+   * a static fingerprint to ANRs whose stacktraces contain only system frames and no application
+   * frames.
+   *
+   * @return true if ANR fingerprinting is enabled
+   */
+  public boolean isEnableAnrFingerprinting() {
+    return enableAnrFingerprinting;
+  }
+
+  /**
+   * Sets whether ANR fingerprinting is enabled. When enabled, the SDK assigns static fingerprints
+   * to ANR events that would otherwise produce noisy grouping. Currently, this applies a static
+   * fingerprint to ANRs whose stacktraces contain only system frames and no application frames.
+   *
+   * @param enableAnrFingerprinting true to enable ANR fingerprinting
+   */
+  public void setEnableAnrFingerprinting(final boolean enableAnrFingerprinting) {
+    this.enableAnrFingerprinting = enableAnrFingerprinting;
+  }
+
   static class AndroidUserFeedbackIDialogHandler implements SentryFeedbackOptions.IDialogHandler {
     @Override
     public void showDialog(
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/AggregatedStackTrace.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AggregatedStackTrace.java
new file mode 100644
index 00000000000..99eeeb7e004
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AggregatedStackTrace.java
@@ -0,0 +1,56 @@
+package io.sentry.android.core.anr;
+
+import java.util.Arrays;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@ApiStatus.Internal
+public class AggregatedStackTrace {
+  // the number of frames of the stacktrace
+  final int depth;
+
+  // the quality of the stack trace, higher means better (ratio of app frames: 0.0 to 1.0)
+  final float quality;
+
+  private final StackTraceElement[] stack;
+
+  // 0 is the most detailed frame in the stacktrace
+  private final int stackStartIdx;
+  private final int stackEndIdx;
+
+  // the total number of times this exact stacktrace was captured
+  int count;
+
+  // first time the stacktrace occurred
+  private long startTimeMs;
+
+  // last time the stacktrace occurred
+  private long endTimeMs;
+
+  public AggregatedStackTrace(
+      final StackTraceElement[] stack,
+      final int stackStartIdx,
+      final int stackEndIdx,
+      final long timestampMs,
+      final float quality) {
+    this.stack = stack;
+    this.stackStartIdx = stackStartIdx;
+    this.stackEndIdx = stackEndIdx;
+    this.depth = stackEndIdx - stackStartIdx + 1;
+    this.startTimeMs = timestampMs;
+    this.endTimeMs = timestampMs;
+    this.count = 1;
+    this.quality = quality;
+  }
+
+  public void addOccurrence(final long timestampMs) {
+    this.startTimeMs = Math.min(startTimeMs, timestampMs);
+    this.endTimeMs = Math.max(endTimeMs, timestampMs);
+    this.count++;
+  }
+
+  @NotNull
+  public StackTraceElement[] getStack() {
+    return Arrays.copyOfRange(stack, stackStartIdx, stackEndIdx + 1);
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrCulpritIdentifier.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrCulpritIdentifier.java
new file mode 100644
index 00000000000..447cb106ce1
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrCulpritIdentifier.java
@@ -0,0 +1,165 @@
+package io.sentry.android.core.anr;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+public class AnrCulpritIdentifier {
+
+  // common Java and Android packages who are less relevant for being the actual culprit
+  private static final List<String> systemAndFrameworkPackages = new ArrayList<>(11);
+
+  static {
+    systemAndFrameworkPackages.add("java.lang");
+    systemAndFrameworkPackages.add("java.util");
+
+    systemAndFrameworkPackages.add("android.app");
+    systemAndFrameworkPackages.add("android.os.Handler");
+    systemAndFrameworkPackages.add("android.os.Looper");
+    systemAndFrameworkPackages.add("android.view");
+    systemAndFrameworkPackages.add("android.widget");
+    systemAndFrameworkPackages.add("com.android.internal");
+    systemAndFrameworkPackages.add("com.google.android");
+
+    systemAndFrameworkPackages.add("kotlin");
+    systemAndFrameworkPackages.add("kotlinx.coroutines");
+  }
+
+  private static final class StackTraceKey {
+    private final @NotNull StackTraceElement[] stack;
+    private final int startIdx;
+    private final int endIdx;
+    private final int hashCode;
+
+    StackTraceKey(final @NotNull StackTraceElement[] stack, final int startIdx, final int endIdx) {
+      this.stack = stack;
+      this.startIdx = startIdx;
+      this.endIdx = endIdx;
+      this.hashCode = computeHashCode();
+    }
+
+    private int computeHashCode() {
+      int result = 1;
+      for (int i = startIdx; i <= endIdx; i++) {
+        result = 31 * result + stack[i].hashCode();
+      }
+      return result;
+    }
+
+    @Override
+    public int hashCode() {
+      return hashCode;
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+      if (this == obj) {
+        return true;
+      }
+      if (!(obj instanceof StackTraceKey)) {
+        return false;
+      }
+
+      final @NotNull StackTraceKey other = (StackTraceKey) obj;
+
+      if (hashCode != other.hashCode) {
+        return false;
+      }
+
+      final int length = endIdx - startIdx + 1;
+      final int otherLength = other.endIdx - other.startIdx + 1;
+      if (length != otherLength) {
+        return false;
+      }
+
+      for (int i = 0; i < length; i++) {
+        if (!stack[startIdx + i].equals(other.stack[other.startIdx + i])) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }
+
+  /**
+   * @param stacks a list of stack traces to analyze
+   * @return the most common occurring stacktrace identified as the culprit
+   */
+  @Nullable
+  public static AggregatedStackTrace identify(final @NotNull List<AnrStackTrace> stacks) {
+    if (stacks.isEmpty()) {
+      return null;
+    }
+
+    // fold all stacktraces and count their occurrences
+    final @NotNull Map<StackTraceKey, AggregatedStackTrace> stackTraceMap = new HashMap<>();
+    for (final @NotNull AnrStackTrace stackTrace : stacks) {
+      if (stackTrace.stack.length < 2) {
+        continue;
+      }
+
+      // stack[0] is the most detailed element in the stacktrace
+      // iterate from end to start (length-1 → 0) creating sub-stacks (i..n-1) to find the most
+      // common root cause
+      // count app frames from the end to compute quality scores
+      int appFramesCount = 0;
+
+      for (int i = stackTrace.stack.length - 1; i >= 0; i--) {
+
+        final @NotNull String topMostClassName = stackTrace.stack[i].getClassName();
+        final boolean isSystemFrame = isSystemFrame(topMostClassName);
+        if (!isSystemFrame) {
+          appFramesCount++;
+        }
+
+        final int totalFrames = stackTrace.stack.length - i;
+        final float quality = (float) appFramesCount / totalFrames;
+
+        final @NotNull StackTraceKey key =
+            new StackTraceKey(stackTrace.stack, i, stackTrace.stack.length - 1);
+
+        @Nullable AggregatedStackTrace aggregatedStackTrace = stackTraceMap.get(key);
+        if (aggregatedStackTrace == null) {
+          aggregatedStackTrace =
+              new AggregatedStackTrace(
+                  stackTrace.stack,
+                  i,
+                  stackTrace.stack.length - 1,
+                  stackTrace.timestampMs,
+                  quality);
+          stackTraceMap.put(key, aggregatedStackTrace);
+        } else {
+          aggregatedStackTrace.addOccurrence(stackTrace.timestampMs);
+        }
+      }
+    }
+
+    if (stackTraceMap.isEmpty()) {
+      return null;
+    }
+
+    // the deepest stacktrace with most count wins
+    return Collections.max(
+        stackTraceMap.values(),
+        (c1, c2) ->
+            Float.compare(
+                c1.count * (1.0f + c1.quality) * c1.depth,
+                c2.count * (1.0f + c2.quality) * c2.depth));
+  }
+
+  public static boolean isSystemFrame(final @NotNull String clazz) {
+    for (final String systemPackage : systemAndFrameworkPackages) {
+      if (clazz.startsWith(systemPackage)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfile.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfile.java
new file mode 100644
index 00000000000..19999683905
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfile.java
@@ -0,0 +1,35 @@
+package io.sentry.android.core.anr;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@ApiStatus.Internal
+public class AnrProfile {
+  public final List<AnrStackTrace> stacks;
+
+  public final long startTimeMs;
+  public final long endTimeMs;
+
+  public AnrProfile(final @NotNull List<AnrStackTrace> stacks) {
+    this.stacks = new ArrayList<>(stacks.size());
+    for (AnrStackTrace stack : stacks) {
+      if (stack != null) {
+        this.stacks.add(stack);
+      }
+    }
+    Collections.sort(this.stacks);
+
+    if (!this.stacks.isEmpty()) {
+      startTimeMs = this.stacks.get(0).timestampMs;
+
+      // adding 10s to be less strict around end time
+      endTimeMs = this.stacks.get(this.stacks.size() - 1).timestampMs + 10_000L;
+    } else {
+      startTimeMs = 0L;
+      endTimeMs = 0L;
+    }
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfileManager.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfileManager.java
new file mode 100644
index 00000000000..7e3e1fd514e
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfileManager.java
@@ -0,0 +1,103 @@
+package io.sentry.android.core.anr;
+
+import static io.sentry.SentryLevel.ERROR;
+import static io.sentry.android.core.anr.AnrProfilingIntegration.POLLING_INTERVAL_MS;
+import static io.sentry.android.core.anr.AnrProfilingIntegration.THRESHOLD_ANR_MS;
+
+import io.sentry.ILogger;
+import io.sentry.SentryOptions;
+import io.sentry.cache.tape.ObjectQueue;
+import io.sentry.cache.tape.QueueFile;
+import io.sentry.util.Objects;
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+public class AnrProfileManager implements AutoCloseable {
+
+  private static final int MAX_NUM_STACKTRACES =
+      (int) ((THRESHOLD_ANR_MS / POLLING_INTERVAL_MS) * 2);
+
+  @NotNull private final ObjectQueue<AnrStackTrace> queue;
+
+  public AnrProfileManager(final @NotNull SentryOptions options) {
+    this(
+        options,
+        new File(
+            Objects.requireNonNull(options.getCacheDirPath(), "cacheDirPath is required"),
+            "anr_profile"));
+  }
+
+  public AnrProfileManager(final @NotNull SentryOptions options, final @NotNull File file) {
+    final @NotNull ILogger logger = options.getLogger();
+
+    @Nullable QueueFile queueFile = null;
+    try {
+      try {
+        queueFile = new QueueFile.Builder(file).size(MAX_NUM_STACKTRACES).build();
+      } catch (IOException e) {
+        // if file is corrupted we simply delete it and try to create it again
+        if (!file.delete()) {
+          throw new IOException("Could not delete file");
+        }
+        queueFile = new QueueFile.Builder(file).size(MAX_NUM_STACKTRACES).build();
+      }
+    } catch (IOException e) {
+      logger.log(ERROR, "Failed to create stacktrace queue", e);
+    }
+
+    if (queueFile == null) {
+      queue = ObjectQueue.createEmpty();
+    } else {
+      queue =
+          ObjectQueue.create(
+              queueFile,
+              new ObjectQueue.Converter<AnrStackTrace>() {
+                @Override
+                public AnrStackTrace from(final byte[] source) throws IOException {
+                  // no need to close the streams since they are backed by byte arrays and don't
+                  // hold any resources
+                  final @NotNull ByteArrayInputStream bis = new ByteArrayInputStream(source);
+                  final @NotNull DataInputStream dis = new DataInputStream(bis);
+                  return AnrStackTrace.deserialize(dis);
+                }
+
+                @Override
+                public void toStream(
+                    final @NotNull AnrStackTrace value, final @NotNull OutputStream sink)
+                    throws IOException {
+                  try (final @NotNull DataOutputStream dos = new DataOutputStream(sink)) {
+                    value.serialize(dos);
+                    dos.flush();
+                    sink.flush();
+                  }
+                }
+              });
+    }
+  }
+
+  public void clear() throws IOException {
+    queue.clear();
+  }
+
+  public void add(AnrStackTrace trace) throws IOException {
+    queue.add(trace);
+  }
+
+  @NotNull
+  public AnrProfile load() throws IOException {
+    return new AnrProfile(queue.asList());
+  }
+
+  @Override
+  public void close() throws IOException {
+    queue.close();
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfileRotationHelper.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfileRotationHelper.java
new file mode 100644
index 00000000000..761309f1670
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfileRotationHelper.java
@@ -0,0 +1,73 @@
+package io.sentry.android.core.anr;
+
+import java.io.File;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Coordinates file rotation between AnrProfilingIntegration and AnrV2Integration to prevent
+ * concurrent access to the same QueueFile.
+ */
+@ApiStatus.Internal
+public class AnrProfileRotationHelper {
+
+  private static final String RECORDING_FILE_NAME = "anr_profile";
+  private static final String OLD_FILE_NAME = "anr_profile_old";
+
+  private static final AtomicBoolean shouldRotate = new AtomicBoolean(true);
+  private static final Object rotationLock = new Object();
+
+  public static void rotate() {
+    shouldRotate.set(true);
+  }
+
+  private static void performRotationIfNeeded(final @NotNull File cacheDir) {
+    if (!shouldRotate.get()) {
+      return;
+    }
+
+    synchronized (rotationLock) {
+      if (!shouldRotate.get()) {
+        return;
+      }
+
+      final File currentFile = new File(cacheDir, RECORDING_FILE_NAME);
+      final File oldFile = new File(cacheDir, OLD_FILE_NAME);
+
+      try {
+        oldFile.delete();
+      } catch (Throwable e) {
+        // ignored
+      }
+
+      try {
+        currentFile.renameTo(oldFile);
+      } catch (Throwable e) {
+        // ignored
+      }
+
+      shouldRotate.set(false);
+    }
+  }
+
+  @NotNull
+  public static File getFileForRecording(final @NotNull File cacheDir) {
+    performRotationIfNeeded(cacheDir);
+    return new File(cacheDir, RECORDING_FILE_NAME);
+  }
+
+  @NotNull
+  public static File getLastFile(final @NotNull File cacheDir) {
+    performRotationIfNeeded(cacheDir);
+    return new File(cacheDir, OLD_FILE_NAME);
+  }
+
+  public static boolean deleteLastFile(final @NotNull File cacheDir) {
+    final File oldFile = new File(cacheDir, OLD_FILE_NAME);
+    if (!oldFile.exists()) {
+      return true;
+    }
+    return oldFile.delete();
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfilingIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfilingIntegration.java
new file mode 100644
index 00000000000..97ec0434249
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrProfilingIntegration.java
@@ -0,0 +1,308 @@
+package io.sentry.android.core.anr;
+
+import static io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
+import io.sentry.ILogger;
+import io.sentry.IScopes;
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.Integration;
+import io.sentry.NoOpLogger;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import io.sentry.android.core.AppState;
+import io.sentry.android.core.SentryAndroidOptions;
+import io.sentry.util.AutoClosableReentrantLock;
+import io.sentry.util.Objects;
+import io.sentry.util.SentryRandom;
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
+
+public class AnrProfilingIntegration
+    implements Integration, Closeable, AppState.AppStateListener, Runnable {
+
+  public static final long POLLING_INTERVAL_MS = 66;
+  private static final long THRESHOLD_SUSPICION_MS = 1000;
+  public static final long THRESHOLD_ANR_MS = 4000;
+  static final int MAX_NUM_STACKS = (int) (10_000 / POLLING_INTERVAL_MS);
+
+  private final AtomicBoolean enabled = new AtomicBoolean(true);
+  private final Runnable updater = () -> lastMainThreadExecutionTime = SystemClock.uptimeMillis();
+  private final @NotNull AutoClosableReentrantLock lifecycleLock = new AutoClosableReentrantLock();
+  private final @NotNull AutoClosableReentrantLock profileManagerLock =
+      new AutoClosableReentrantLock();
+
+  private volatile long lastMainThreadExecutionTime = SystemClock.uptimeMillis();
+  final AtomicInteger numCollectedStacks = new AtomicInteger();
+  private volatile MainThreadState mainThreadState = MainThreadState.IDLE;
+  private volatile @Nullable AnrProfileManager profileManager;
+  private volatile @NotNull ILogger logger = NoOpLogger.getInstance();
+  private volatile @Nullable SentryAndroidOptions options;
+  private volatile @Nullable Thread thread = null;
+  private volatile boolean sampled = false;
+  private volatile boolean inForeground = false;
+  private volatile @Nullable Handler mainHandler;
+  private volatile @Nullable Thread mainThread;
+
+  @Override
+  public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions options) {
+    this.options =
+        Objects.requireNonNull(
+            (options instanceof SentryAndroidOptions) ? (SentryAndroidOptions) options : null,
+            "SentryAndroidOptions is required");
+    this.logger = options.getLogger();
+
+    if (this.options.isAnrProfilingEnabled()) {
+      if (this.options.getCacheDirPath() == null) {
+        logger.log(SentryLevel.WARNING, "ANR Profiling is enabled but cacheDirPath is not set");
+        return;
+      }
+
+      final Looper mainLooper = Looper.getMainLooper();
+      this.mainThread = mainLooper.getThread();
+      this.mainHandler = new Handler(mainLooper);
+
+      addIntegrationToSdkVersion("AnrProfiling");
+      AppState.getInstance().addAppStateListener(this);
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    enabled.set(false);
+    AppState.getInstance().removeAppStateListener(this);
+
+    // Remove any pending updater callbacks from the main handler
+    final @Nullable Handler handler = mainHandler;
+    if (handler != null) {
+      handler.removeCallbacks(updater);
+    }
+
+    // Wake and interrupt the thread so it exits
+    final @Nullable Thread t = thread;
+    if (t != null) {
+      synchronized (this) {
+        notifyAll();
+      }
+      t.interrupt();
+    }
+
+    final @Nullable SentryAndroidOptions opts = options;
+    final @Nullable AnrProfileManager pm;
+    try (final @NotNull ISentryLifecycleToken ignored = profileManagerLock.acquire()) {
+      pm = profileManager;
+      profileManager = null;
+    }
+    if (opts != null) {
+      try {
+        opts.getExecutorService()
+            .submit(
+                () -> {
+                  if (pm == null) {
+                    return;
+                  }
+
+                  try {
+                    pm.close();
+                  } catch (IOException e) {
+                    logger.log(SentryLevel.WARNING, "Failed to close AnrProfileManager");
+                  }
+                });
+      } catch (Throwable e) {
+        logger.log(SentryLevel.WARNING, "Failed to submit AnrProfileManager close");
+      }
+    }
+  }
+
+  @Override
+  public void onForeground() {
+    if (!enabled.get()) {
+      return;
+    }
+    try (final @NotNull ISentryLifecycleToken ignored = lifecycleLock.acquire()) {
+      if (inForeground) {
+        return;
+      }
+      inForeground = true;
+      updater.run();
+
+      final @Nullable Thread existingThread = thread;
+      if (existingThread != null && existingThread.isAlive()) {
+        // Wake the existing thread
+        synchronized (this) {
+          notifyAll();
+        }
+      }
+      if (existingThread == null || !existingThread.isAlive()) {
+        final @NotNull Thread profilingThread = new Thread(this, "AnrProfilingIntegration");
+        profilingThread.setDaemon(true);
+        profilingThread.start();
+        thread = profilingThread;
+      }
+    }
+  }
+
+  @Override
+  public void onBackground() {
+    if (!enabled.get()) {
+      return;
+    }
+    try (final @NotNull ISentryLifecycleToken ignored = lifecycleLock.acquire()) {
+      inForeground = false;
+    }
+  }
+
+  @Override
+  public void run() {
+    final @Nullable Handler handler = mainHandler;
+    final @Nullable Thread mt = mainThread;
+    if (handler == null || mt == null) {
+      return;
+    }
+
+    try {
+      while (enabled.get() && !Thread.currentThread().isInterrupted()) {
+        try {
+          if (!inForeground) {
+            // Wait until we're back in the foreground or disabled
+            synchronized (this) {
+              while (!inForeground && enabled.get()) {
+                wait();
+              }
+            }
+            // Reset the updater timestamp after waking to avoid false suspicion
+            updater.run();
+            continue;
+          }
+
+          checkMainThread(mt);
+
+          handler.removeCallbacks(updater);
+          handler.post(updater);
+
+          // noinspection BusyWait
+          Thread.sleep(POLLING_INTERVAL_MS);
+        } catch (InterruptedException e) {
+          // Restore interrupt status and exit the polling loop
+          Thread.currentThread().interrupt();
+          return;
+        }
+      }
+    } catch (Throwable t) {
+      logger.log(SentryLevel.WARNING, "Failed to execute AnrStacktraceIntegration", t);
+    }
+  }
+
+  @ApiStatus.Internal
+  protected void checkMainThread(final @NotNull Thread mainThread) throws IOException {
+    final long now = SystemClock.uptimeMillis();
+    final long diff = now - lastMainThreadExecutionTime;
+
+    if (diff < THRESHOLD_SUSPICION_MS) {
+      mainThreadState = MainThreadState.IDLE;
+      sampled = false;
+    }
+
+    if (mainThreadState == MainThreadState.IDLE && diff > THRESHOLD_SUSPICION_MS) {
+      if (logger.isEnabled(SentryLevel.DEBUG)) {
+        logger.log(SentryLevel.DEBUG, "ANR: main thread is suspicious");
+      }
+      mainThreadState = MainThreadState.SUSPICIOUS;
+
+      final @Nullable SentryAndroidOptions opts = options;
+      final @Nullable Double sampleRate = opts != null ? opts.getAnrProfilingSampleRate() : null;
+      if (sampleRate != null && SentryRandom.current().nextDouble() < sampleRate) {
+        sampled = true;
+      }
+
+      if (sampled) {
+        clearStacks();
+      }
+    }
+
+    // if we are suspicious and sampled, we need to collect stack traces
+    if (sampled
+        && (mainThreadState == MainThreadState.SUSPICIOUS
+            || mainThreadState == MainThreadState.ANR_DETECTED)) {
+      if (numCollectedStacks.get() < MAX_NUM_STACKS) {
+        final long start = SystemClock.uptimeMillis();
+        final @NotNull AnrStackTrace trace =
+            new AnrStackTrace(System.currentTimeMillis(), mainThread.getStackTrace());
+        final long duration = SystemClock.uptimeMillis() - start;
+        if (logger.isEnabled(SentryLevel.DEBUG)) {
+          logger.log(
+              SentryLevel.DEBUG,
+              "AnrWatchdog: capturing main thread stacktrace took " + duration + "ms");
+        }
+        addStackTrace(trace);
+      } else {
+        if (logger.isEnabled(SentryLevel.DEBUG)) {
+          logger.log(
+              SentryLevel.DEBUG,
+              "ANR: reached maximum number of collected stack traces, skipping further collection");
+        }
+      }
+    }
+
+    if (mainThreadState == MainThreadState.SUSPICIOUS && diff > THRESHOLD_ANR_MS) {
+      if (logger.isEnabled(SentryLevel.DEBUG)) {
+        logger.log(SentryLevel.DEBUG, "ANR: main thread ANR threshold reached");
+      }
+      mainThreadState = MainThreadState.ANR_DETECTED;
+    }
+  }
+
+  @TestOnly
+  @NotNull
+  protected MainThreadState getState() {
+    return mainThreadState;
+  }
+
+  @TestOnly
+  @NotNull
+  protected AnrProfileManager getProfileManager() {
+    try (final @NotNull ISentryLifecycleToken ignored = profileManagerLock.acquire()) {
+      if (profileManager == null) {
+        final @NotNull SentryOptions opts =
+            Objects.requireNonNull(options, "Options can't be null");
+        final @Nullable String cacheDirPath = opts.getCacheDirPath();
+        if (cacheDirPath == null) {
+          throw new IllegalStateException("cacheDirPath is required for ANR profiling");
+        }
+        final @NotNull File currentFile =
+            AnrProfileRotationHelper.getFileForRecording(new File(cacheDirPath));
+        profileManager = new AnrProfileManager(opts, currentFile);
+      }
+
+      return profileManager;
+    }
+  }
+
+  private void clearStacks() throws IOException {
+    numCollectedStacks.set(0);
+    getProfileManager().clear();
+  }
+
+  private void addStackTrace(@NotNull final AnrStackTrace trace) throws IOException {
+    if (!enabled.get()) {
+      return;
+    }
+    numCollectedStacks.incrementAndGet();
+    getProfileManager().add(trace);
+  }
+
+  protected enum MainThreadState {
+    IDLE,
+    SUSPICIOUS,
+    ANR_DETECTED,
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrStackTrace.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrStackTrace.java
new file mode 100644
index 00000000000..2d165c501bf
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/AnrStackTrace.java
@@ -0,0 +1,79 @@
+package io.sentry.android.core.anr;
+
+import io.sentry.util.StringUtils;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+public final class AnrStackTrace implements Comparable<AnrStackTrace> {
+
+  private static final int MAX_STACK_LENGTH = 1000;
+
+  public final StackTraceElement[] stack;
+  public final long timestampMs;
+
+  public AnrStackTrace(final long timestampMs, final StackTraceElement[] stack) {
+    this.timestampMs = timestampMs;
+    this.stack = stack;
+  }
+
+  @Override
+  public int compareTo(final @NotNull AnrStackTrace o) {
+    return Long.compare(timestampMs, o.timestampMs);
+  }
+
+  public void serialize(final @NotNull DataOutputStream dos) throws IOException {
+    dos.writeShort(1); // version
+    dos.writeLong(timestampMs);
+    dos.writeInt(stack.length);
+    for (final @NotNull StackTraceElement element : stack) {
+      dos.writeUTF(StringUtils.getOrEmpty(element.getClassName()));
+      dos.writeUTF(StringUtils.getOrEmpty(element.getMethodName()));
+      // Write null as a special marker to preserve null vs empty string distinction
+      final @Nullable String fileName = element.getFileName();
+      dos.writeBoolean(fileName == null);
+      dos.writeUTF(fileName == null ? "" : fileName);
+      dos.writeInt(element.getLineNumber());
+    }
+  }
+
+  @Nullable
+  public static AnrStackTrace deserialize(final @NotNull DataInputStream dis) throws IOException {
+    try {
+      final short version = dis.readShort();
+      if (version == 1) {
+        final long timestampMs = dis.readLong();
+        final int stackLength = dis.readInt();
+        if (stackLength < 0 || stackLength > MAX_STACK_LENGTH) {
+          return null;
+        }
+        final @NotNull StackTraceElement[] stack = new StackTraceElement[stackLength];
+
+        for (int i = 0; i < stackLength; i++) {
+          final @NotNull String className = dis.readUTF();
+          final @NotNull String methodName = dis.readUTF();
+          // Read the null marker to restore null vs empty string distinction
+          final boolean isFileNameNull = dis.readBoolean();
+          final @NotNull String fileNameStr = dis.readUTF();
+          final @Nullable String fileName = isFileNameNull ? null : fileNameStr;
+          final int lineNumber = dis.readInt();
+          final StackTraceElement element =
+              new StackTraceElement(className, methodName, fileName, lineNumber);
+          stack[i] = element;
+        }
+
+        return new AnrStackTrace(timestampMs, stack);
+      } else {
+        // unsupported future version
+        return null;
+      }
+    } catch (EOFException e) {
+      return null;
+    }
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/StackTraceConverter.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/StackTraceConverter.java
new file mode 100644
index 00000000000..f6f29689f72
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/StackTraceConverter.java
@@ -0,0 +1,150 @@
+package io.sentry.android.core.anr;
+
+import io.sentry.protocol.SentryStackFrame;
+import io.sentry.protocol.profiling.SentryProfile;
+import io.sentry.protocol.profiling.SentrySample;
+import io.sentry.protocol.profiling.SentryThreadMetadata;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Converts a list of {@link AnrStackTrace} objects captured during ANR detection into a {@link
+ * SentryProfile} object suitable for profiling telemetry.
+ *
+ * <p>This converter handles:
+ *
+ * <ul>
+ *   <li>Converting {@link StackTraceElement} to {@link SentryStackFrame}
+ *   <li>Deduplicating frames based on their signature
+ *   <li>Building stack references using frame indices
+ *   <li>Creating samples with timestamps
+ *   <li>Populating thread metadata
+ * </ul>
+ */
+@ApiStatus.Internal
+public final class StackTraceConverter {
+
+  private static final String MAIN_THREAD_ID = "0";
+  private static final String MAIN_THREAD_NAME = "main";
+
+  /**
+   * Converts a list of {@link AnrStackTrace} objects to a {@link SentryProfile}.
+   *
+   * @param anrProfile The ANR Profile
+   * @return a populated SentryProfile with deduped frames and samples
+   */
+  @NotNull
+  public static SentryProfile convert(final @NotNull AnrProfile anrProfile) {
+    final @NotNull List<AnrStackTrace> anrStackTraces = anrProfile.stacks;
+
+    final @NotNull SentryProfile profile = new SentryProfile();
+    final @NotNull List<SentryStackFrame> frames = new ArrayList<>();
+    final @NotNull Map<String, Integer> frameSignatureToIndex = new HashMap<>();
+    final @NotNull List<List<Integer>> stacks = new ArrayList<>();
+    final @NotNull Map<String, Integer> stackSignatureToIndex = new HashMap<>();
+
+    for (final @NotNull AnrStackTrace anrStackTrace : anrStackTraces) {
+      final @NotNull StackTraceElement[] stackElements = anrStackTrace.stack;
+      final @NotNull List<Integer> frameIndices = new ArrayList<>();
+      for (final @NotNull StackTraceElement element : stackElements) {
+        final @NotNull String frameSignature = createFrameSignature(element);
+        @Nullable Integer frameIndex = frameSignatureToIndex.get(frameSignature);
+        if (frameIndex == null) {
+          frameIndex = frames.size();
+          frames.add(createSentryStackFrame(element));
+          frameSignatureToIndex.put(frameSignature, frameIndex);
+        }
+        frameIndices.add(frameIndex);
+      }
+
+      final @NotNull String stackSignature = createStackSignature(frameIndices);
+      @Nullable Integer stackIndex = stackSignatureToIndex.get(stackSignature);
+
+      if (stackIndex == null) {
+        stackIndex = stacks.size();
+        stacks.add(new ArrayList<>(frameIndices));
+        stackSignatureToIndex.put(stackSignature, stackIndex);
+      }
+
+      final @NotNull SentrySample sample = new SentrySample();
+      sample.setTimestamp(anrStackTrace.timestampMs / 1000.0); // Convert ms to seconds
+      sample.setStackId(stackIndex);
+      sample.setThreadId(MAIN_THREAD_ID);
+
+      profile.getSamples().add(sample);
+    }
+
+    profile.setFrames(frames);
+    profile.setStacks(stacks);
+
+    final @NotNull SentryThreadMetadata threadMetadata = new SentryThreadMetadata();
+    threadMetadata.setName(MAIN_THREAD_NAME);
+    threadMetadata.setPriority(Thread.NORM_PRIORITY);
+
+    final @NotNull Map<String, SentryThreadMetadata> threadMetadataMap =
+        Collections.singletonMap(MAIN_THREAD_ID, threadMetadata);
+    profile.setThreadMetadata(threadMetadataMap);
+
+    return profile;
+  }
+
+  /**
+   * Creates a unique signature for a StackTraceElement to identify duplicate frames.
+   *
+   * @param element the stack trace element
+   * @return a signature string representing this frame
+   */
+  @NotNull
+  private static String createFrameSignature(@NotNull StackTraceElement element) {
+    return element.getClassName()
+        + "#"
+        + element.getMethodName()
+        + "#"
+        + element.getFileName()
+        + "#"
+        + element.getLineNumber();
+  }
+
+  /**
+   * Creates a unique signature for a stack (list of frame indices) to identify duplicate stacks.
+   *
+   * @param frameIndices the list of frame indices
+   * @return a signature string representing this stack
+   */
+  @NotNull
+  private static String createStackSignature(@NotNull List<Integer> frameIndices) {
+    final @NotNull StringBuilder sb = new StringBuilder();
+    for (Integer index : frameIndices) {
+      if (sb.length() > 0) {
+        sb.append(",");
+      }
+      sb.append(index);
+    }
+    return sb.toString();
+  }
+
+  /**
+   * Converts a {@link StackTraceElement} to a {@link SentryStackFrame}.
+   *
+   * @param element the stack trace element
+   * @return a SentryStackFrame populated with available information
+   */
+  @NotNull
+  private static SentryStackFrame createSentryStackFrame(@NotNull StackTraceElement element) {
+    final @NotNull SentryStackFrame frame = new SentryStackFrame();
+    frame.setFilename(element.getFileName());
+    frame.setFunction(element.getMethodName());
+    frame.setModule(element.getClassName());
+    frame.setLineno(element.getLineNumber() > 0 ? element.getLineNumber() : null);
+    if (element.isNativeMethod()) {
+      frame.setNative(true);
+    }
+    return frame;
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ANRWatchDogTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ANRWatchDogTest.kt
index c2c3d384c40..2f3b6791c5b 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ANRWatchDogTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ANRWatchDogTest.kt
@@ -58,8 +58,8 @@ class ANRWatchDogTest {
       } while (anr == null && waitCount++ < 100)
 
       assertNotNull(anr)
-      assertEquals(expectedState, anr!!.thread.state)
-      assertEquals(stacktrace.className, anr!!.stackTrace[0].className)
+      assertEquals(expectedState, anr.thread!!.state)
+      assertEquals(stacktrace.className, anr.stackTrace[0].className)
     } finally {
       sut.interrupt()
       es.shutdown()
@@ -137,8 +137,8 @@ class ANRWatchDogTest {
       } while (anr == null && waitCount++ < 100)
 
       assertNotNull(anr)
-      assertEquals(expectedState, anr!!.thread.state)
-      assertEquals(stacktrace.className, anr!!.stackTrace[0].className)
+      assertEquals(expectedState, anr.thread!!.state)
+      assertEquals(stacktrace.className, anr.stackTrace[0].className)
     } finally {
       sut.interrupt()
       es.shutdown()
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2IntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2IntegrationTest.kt
index a1a35facf56..abd27b51560 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2IntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2IntegrationTest.kt
@@ -8,13 +8,17 @@ import io.sentry.SentryEvent
 import io.sentry.android.core.AnrV2Integration.AnrV2Hint
 import io.sentry.android.core.cache.AndroidEnvelopeCache
 import io.sentry.util.HintUtils
+import java.io.File
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
+import org.junit.After
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
+import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.argThat
 import org.mockito.kotlin.check
+import org.mockito.kotlin.never
 import org.mockito.kotlin.spy
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
@@ -159,6 +163,11 @@ class AnrV2IntegrationTest : ApplicationExitIntegrationTestBase<AnrV2Hint>() {
     assertEquals("/apex/com.android.runtime/lib64/bionic/libc.so", image.codeFile)
   }
 
+  @After
+  fun cleanup() {
+    fixture.options.cacheDirPath?.let { File(it).deleteRecursively() }
+  }
+
   @Test
   fun `when latest ANR has foreground importance, sets abnormal mechanism to anr_foreground`() {
     val integration =
@@ -211,4 +220,24 @@ class AnrV2IntegrationTest : ApplicationExitIntegrationTestBase<AnrV2Hint>() {
 
     verify(fixture.scopes).captureEvent(any(), check<Hint> { assertNotNull(it.threadDump) })
   }
+
+  @Test
+  fun `when traceInputStream is null, does not report ANR`() {
+    val integration = fixture.getSut(tmpDir, lastReportedTimestamp = oldTimestamp)
+    fixture.addAppExitInfo(timestamp = newTimestamp, addTrace = false)
+
+    integration.register(fixture.scopes, fixture.options)
+
+    verify(fixture.scopes, never()).captureEvent(any(), anyOrNull<Hint>())
+  }
+
+  @Test
+  fun `when traceInputStream has bad data, does not report ANR`() {
+    val integration = fixture.getSut(tmpDir, lastReportedTimestamp = oldTimestamp)
+    fixture.addAppExitInfo(timestamp = newTimestamp, addBadTrace = true)
+
+    integration.register(fixture.scopes, fixture.options)
+
+    verify(fixture.scopes, never()).captureEvent(any(), anyOrNull<Hint>())
+  }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
index 66090fc815e..e7583429910 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
@@ -8,13 +8,18 @@ import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.Breadcrumb
 import io.sentry.Hint
+import io.sentry.IScopes
 import io.sentry.IpAddressUtils
 import io.sentry.NoOpLogger
+import io.sentry.Sentry
 import io.sentry.SentryBaseEvent
 import io.sentry.SentryEvent
 import io.sentry.SentryLevel
 import io.sentry.SentryLevel.DEBUG
 import io.sentry.SpanContext
+import io.sentry.android.core.anr.AnrProfileManager
+import io.sentry.android.core.anr.AnrProfileRotationHelper
+import io.sentry.android.core.anr.AnrStackTrace
 import io.sentry.cache.PersistingOptionsObserver.DIST_FILENAME
 import io.sentry.cache.PersistingOptionsObserver.ENVIRONMENT_FILENAME
 import io.sentry.cache.PersistingOptionsObserver.OPTIONS_CACHE
@@ -67,6 +72,8 @@ import kotlin.test.assertTrue
 import org.junit.Rule
 import org.junit.rules.TemporaryFolder
 import org.junit.runner.RunWith
+import org.mockito.Mockito.mockStatic
+import org.mockito.kotlin.any
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
 import org.robolectric.annotation.Config
@@ -596,12 +603,44 @@ class ApplicationExitInfoEventProcessorTest {
   fun `sets default fingerprint to distinguish between background and foreground ANRs`() {
     val backgroundHint =
       HintUtils.createWithTypeCheckHint(AbnormalExitHint(mechanism = "anr_background"))
-    val processedBackground = processEvent(backgroundHint, populateScopeCache = false)
+    val processedBackground =
+      processEvent(backgroundHint, populateScopeCache = false) {
+        exceptions =
+          listOf(
+            SentryException().apply {
+              this.stacktrace =
+                SentryStackTrace(
+                  listOf(
+                    SentryStackFrame().apply {
+                      module = "io.sentry.samples.MainActivity"
+                      function = "run"
+                    }
+                  )
+                )
+            }
+          )
+      }
     assertEquals(listOf("{{ default }}", "background-anr"), processedBackground.fingerprints)
 
     val foregroundHint =
       HintUtils.createWithTypeCheckHint(AbnormalExitHint(mechanism = "anr_foreground"))
-    val processedForeground = processEvent(foregroundHint, populateScopeCache = false)
+    val processedForeground =
+      processEvent(foregroundHint, populateScopeCache = false) {
+        exceptions =
+          listOf(
+            SentryException().apply {
+              this.stacktrace =
+                SentryStackTrace(
+                  listOf(
+                    SentryStackFrame().apply {
+                      module = "io.sentry.samples.MainActivity"
+                      function = "run"
+                    }
+                  )
+                )
+            }
+          )
+      }
     assertEquals(listOf("{{ default }}", "foreground-anr"), processedForeground.fingerprints)
   }
 
@@ -628,6 +667,181 @@ class ApplicationExitInfoEventProcessorTest {
     assertNull(processed.fingerprints)
   }
 
+  @Test
+  fun `sets system-frames-only fingerprint when ANR fingerprinting enabled and no app frames`() {
+    fixture.options.isEnableAnrFingerprinting = true
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(mechanism = "anr_foreground"))
+
+    val processed =
+      processEvent(hint, populateScopeCache = false) {
+        threads =
+          listOf(
+            SentryThread().apply {
+              name = "main"
+              stacktrace =
+                SentryStackTrace().apply {
+                  frames =
+                    listOf(
+                      SentryStackFrame().apply {
+                        module = "java.lang"
+                        filename = "Thread.java"
+                        function = "run"
+                      }
+                    )
+                }
+            }
+          )
+      }
+
+    assertEquals(listOf("system-frames-only-anr", "foreground-anr"), processed.fingerprints)
+  }
+
+  @Test
+  fun `does not set system-frames-only fingerprint when ANR fingerprinting is disabled and no app frames are present`() {
+    fixture.options.isEnableAnrFingerprinting = false
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(mechanism = "anr_foreground"))
+
+    val processed =
+      processEvent(hint, populateScopeCache = false) {
+        threads =
+          listOf(
+            SentryThread().apply {
+              name = "main"
+              stacktrace =
+                SentryStackTrace().apply {
+                  frames =
+                    listOf(
+                      SentryStackFrame().apply {
+                        module = "java.lang"
+                        filename = "Thread.java"
+                        function = "run"
+                      }
+                    )
+                }
+            }
+          )
+      }
+
+    assertEquals(listOf("{{ default }}", "foreground-anr"), processed.fingerprints)
+  }
+
+  @Test
+  fun `sets default fingerprint when ANR fingerprinting enabled and app frames are present`() {
+    fixture.options.isEnableAnrFingerprinting = true
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(mechanism = "anr_foreground"))
+
+    val processed =
+      processEvent(hint, populateScopeCache = false) {
+        threads =
+          listOf(
+            SentryThread().apply {
+              name = "main"
+              stacktrace =
+                SentryStackTrace().apply {
+                  frames =
+                    listOf(
+                      SentryStackFrame().apply {
+                        module = "com.example.MyApp"
+                        function = "onCreate"
+                      }
+                    )
+                }
+            }
+          )
+      }
+
+    assertEquals(listOf("{{ default }}", "foreground-anr"), processed.fingerprints)
+  }
+
+  @Test
+  fun `does not set profile context when ANR profiling is disabled`() {
+    fixture.options.anrProfilingSampleRate = null
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(mechanism = "anr_foreground"))
+    val processed =
+      processEvent(hint, populateScopeCache = false) {
+        threads =
+          listOf(
+            SentryThread().apply {
+              name = "main"
+              stacktrace =
+                SentryStackTrace().apply {
+                  frames =
+                    listOf(
+                      SentryStackFrame().apply {
+                        module = "com.example.MyApp"
+                        function = "onCreate"
+                      }
+                    )
+                }
+            }
+          )
+      }
+    assertNull(processed.contexts.profile)
+  }
+
+  @Test
+  fun `applies ANR profile if available`() {
+    fixture.options.anrProfilingSampleRate = 1.0
+    val processor =
+      fixture.getSut(
+        tmpDir,
+        populateScopeCache = false,
+        populateOptionsCache = false,
+        isSendDefaultPii = false,
+      )
+
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(mechanism = "anr_foreground"))
+
+    AnrProfileManager(
+        fixture.options,
+        AnrProfileRotationHelper.getFileForRecording(File(fixture.options.cacheDirPath!!)),
+      )
+      .apply {
+        add(
+          AnrStackTrace(
+            System.currentTimeMillis(),
+            arrayOf(
+              StackTraceElement(
+                "android.view.Choreographer",
+                "doFrame",
+                "Choreographer.java",
+                1234,
+              ),
+              StackTraceElement("android.os.Handler", "dispatchMessage", "Handler.java", 5678),
+            ),
+          )
+        )
+        close()
+      }
+    AnrProfileRotationHelper.rotate()
+
+    val scopes = mock<IScopes>()
+    whenever(scopes.captureProfileChunk(any())).thenReturn(SentryId())
+
+    mockStatic(Sentry::class.java).use { mockedSentry ->
+      mockedSentry.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(scopes)
+
+      val processed = processor.process(SentryEvent(), hint)
+
+      assertNotNull(processed?.contexts?.profile)
+      assertNotNull(processed.contexts.profile?.profilerId)
+    }
+  }
+
+  @Test
+  fun `does not crash when ANR profiling is enabled but cache dir is null`() {
+    fixture.options.anrProfilingSampleRate = 1.0
+    fixture.options.cacheDirPath = null
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(mechanism = "anr_foreground"))
+    val original = SentryEvent()
+
+    val processor = fixture.getSut(tmpDir)
+    val processed = processor.process(original, hint)
+
+    assertNotNull(processed)
+    assertNull(processed.contexts.profile)
+  }
+
   @Test
   fun `sets replayId when replay folder exists`() {
     val hint = HintUtils.createWithTypeCheckHint(BackfillableHint())
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitIntegrationTestBase.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitIntegrationTestBase.kt
index ff30dfb2e10..649e14e413b 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitIntegrationTestBase.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitIntegrationTestBase.kt
@@ -418,6 +418,7 @@ abstract class ApplicationExitIntegrationTestBase<THint : Any> {
         extraOptions(this)
       }
       options.cacheDirPath?.let { cacheDir ->
+        File(cacheDir).mkdirs()
         lastReportedFile = File(cacheDir, config.lastReportedFileName)
         lastReportedFile.writeText(lastReportedTimestamp.toString())
       }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index fd5c9cffc89..b9b7d40e48a 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -1997,6 +1997,56 @@ class ManifestMetadataReaderTest {
     )
   }
 
+  @Test
+  fun `applyMetadata reads anrProfilingSampleRate to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.ANR_PROFILING_SAMPLE_RATE to 0.5f)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(0.5, fixture.options.anrProfilingSampleRate!!, 0.01)
+  }
+
+  @Test
+  fun `applyMetadata keeps anrProfilingSampleRate default when not set in manifest`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertNull(fixture.options.anrProfilingSampleRate)
+  }
+
+  @Test
+  fun `applyMetadata reads enableAnrFingerprinting to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.ENABLE_ANR_FINGERPRINTING to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.isEnableAnrFingerprinting)
+  }
+
+  @Test
+  fun `applyMetadata keeps enableAnrFingerprinting default when not set in manifest`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.isEnableAnrFingerprinting)
+  }
+
   // Network Detail Configuration Tests
 
   @Test
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt
index 8cb79b0bb5b..819928dcdc4 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt
@@ -195,6 +195,44 @@ class SentryAndroidOptionsTest {
     assertTrue(sentryOptions.isEnableSystemEventBreadcrumbsExtras)
   }
 
+  @Test
+  fun `anr profiling sample rate is null by default`() {
+    val sentryOptions = SentryAndroidOptions()
+
+    assertNull(sentryOptions.anrProfilingSampleRate)
+    assertFalse(sentryOptions.isAnrProfilingEnabled)
+  }
+
+  @Test
+  fun `anr profiling can be enabled via sample rate`() {
+    val sentryOptions = SentryAndroidOptions()
+    sentryOptions.anrProfilingSampleRate = 1.0
+    assertEquals(1.0, sentryOptions.anrProfilingSampleRate)
+    assertTrue(sentryOptions.isAnrProfilingEnabled)
+  }
+
+  @Test
+  fun `anr profiling can be disabled via null sample rate`() {
+    val sentryOptions = SentryAndroidOptions()
+    sentryOptions.anrProfilingSampleRate = 1.0
+    sentryOptions.anrProfilingSampleRate = null
+    assertNull(sentryOptions.anrProfilingSampleRate)
+    assertFalse(sentryOptions.isAnrProfilingEnabled)
+  }
+
+  @Test
+  fun `anr profiling is disabled when sample rate is zero`() {
+    val sentryOptions = SentryAndroidOptions()
+    sentryOptions.anrProfilingSampleRate = 0.0
+    assertFalse(sentryOptions.isAnrProfilingEnabled)
+  }
+
+  @Test(expected = IllegalArgumentException::class)
+  fun `anr profiling rejects invalid sample rate`() {
+    val sentryOptions = SentryAndroidOptions()
+    sentryOptions.anrProfilingSampleRate = 2.0
+  }
+
   private class CustomDebugImagesLoader : IDebugImagesLoader {
     override fun loadDebugImages(): List<DebugImage>? = null
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
index b7fad8abee2..c0010fa64e3 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
@@ -29,6 +29,7 @@ import io.sentry.Session
 import io.sentry.ShutdownHookIntegration
 import io.sentry.SystemOutLogger
 import io.sentry.UncaughtExceptionHandlerIntegration
+import io.sentry.android.core.anr.AnrProfilingIntegration
 import io.sentry.android.core.cache.AndroidEnvelopeCache
 import io.sentry.android.core.performance.AppStartMetrics
 import io.sentry.android.fragment.FragmentLifecycleIntegration
@@ -476,7 +477,7 @@ class SentryAndroidTest {
     fixture.initSut(context = mock<Application>()) { options ->
       optionsRef = options
       options.dsn = "https://key@sentry.io/123"
-      assertEquals(18, options.integrations.size)
+      assertEquals(19, options.integrations.size)
       options.integrations.removeAll {
         it is UncaughtExceptionHandlerIntegration ||
           it is ShutdownHookIntegration ||
@@ -485,6 +486,7 @@ class SentryAndroidTest {
           it is EnvelopeFileObserverIntegration ||
           it is AppLifecycleIntegration ||
           it is AnrIntegration ||
+          it is AnrProfilingIntegration ||
           it is ActivityLifecycleIntegration ||
           it is ActivityBreadcrumbsIntegration ||
           it is UserInteractionIntegration ||
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrCulpritIdentifierTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrCulpritIdentifierTest.kt
new file mode 100644
index 00000000000..c4c9c947c99
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrCulpritIdentifierTest.kt
@@ -0,0 +1,167 @@
+package io.sentry.android.core.anr
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+class AnrCulpritIdentifierTest {
+
+  @Test
+  fun `returns null for empty dumps`() {
+    val dumps = emptyList<AnrStackTrace>()
+    val result = AnrCulpritIdentifier.identify(dumps)
+    assertNull(result)
+  }
+
+  @Test
+  fun `identifies single stack trace`() {
+    val stackTraceElements =
+      arrayOf(
+        StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42),
+        StackTraceElement("com.example.AnotherClass", "method2", "AnotherClass.java", 100),
+      )
+    val dumps = listOf(AnrStackTrace(1000, stackTraceElements))
+
+    val result = AnrCulpritIdentifier.identify(dumps)
+
+    assertNotNull(result)
+    assertEquals(1, result.count)
+    assertEquals("com.example.MyClass", result.stack.first().className)
+    assertEquals(2, result.depth)
+  }
+
+  @Test
+  fun `identifies most common, most detailed stack trace from multiple dumps`() {
+    val commonElements =
+      arrayOf(
+        StackTraceElement("com.example.CommonClass", "commonMethod1", "CommonClass.java", 42),
+        StackTraceElement("com.example.CommonClass", "commonMethod2", "CommonClass.java", 100),
+      )
+    val rareElements =
+      arrayOf(
+        StackTraceElement("com.example.RareClass", "rareMethod", "RareClass.java", 50),
+        StackTraceElement("com.example.CommonClass", "commonMethod2", "CommonClass.java", 100),
+      )
+    val dumps =
+      listOf(
+        AnrStackTrace(1000, commonElements),
+        AnrStackTrace(2000, commonElements),
+        AnrStackTrace(3000, rareElements),
+      )
+
+    val result = AnrCulpritIdentifier.identify(dumps)
+
+    assertNotNull(result)
+    assertEquals(2, result.count)
+    assertEquals("com.example.CommonClass", result.stack.first().className)
+    assertEquals("commonMethod1", result.stack.first().methodName)
+  }
+
+  @Test
+  fun `provides 0 quality score when stack only contains framework packages`() {
+    val frameworkElements =
+      arrayOf(
+        StackTraceElement("java.lang.Object", "wait", "Object.java", 42),
+        StackTraceElement("android.os.Handler", "handleMessage", "Handler.java", 100),
+      )
+    val dumps =
+      listOf(AnrStackTrace(1000, frameworkElements), AnrStackTrace(2000, frameworkElements))
+
+    val result = AnrCulpritIdentifier.identify(dumps)
+
+    assertNotNull(result)
+    assertEquals(0f, result.quality)
+  }
+
+  @Test
+  fun `applies lower quality score to framework packages`() {
+    val frameworkElements =
+      arrayOf(
+        StackTraceElement("java.lang.Object", "wait", "Object.java", 42),
+        StackTraceElement("android.os.Handler", "handleMessage", "Handler.java", 100),
+      )
+    val appElements =
+      arrayOf(
+        StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42),
+        StackTraceElement("android.os.Handler", "handleMessage", "Handler.java", 100),
+      )
+
+    val dumps = listOf(AnrStackTrace(1000, frameworkElements), AnrStackTrace(2000, appElements))
+
+    val result = AnrCulpritIdentifier.identify(dumps)
+
+    assertNotNull(result)
+    assertEquals("com.example.MyClass", result.stack.first().className)
+  }
+
+  @Test
+  fun `prefers deeper stack traces`() {
+    val shallowStack =
+      arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+
+    val deepStack =
+      arrayOf(
+        StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42),
+        StackTraceElement("com.example.AnotherClass", "method2", "AnotherClass.java", 100),
+        StackTraceElement("com.example.ThirdClass", "method3", "ThirdClass.java", 150),
+      )
+    val dumps = listOf(AnrStackTrace(1000, shallowStack), AnrStackTrace(2000, deepStack))
+
+    val result = AnrCulpritIdentifier.identify(dumps)
+
+    assertNotNull(result)
+    assertEquals(3, result.depth)
+    assertEquals("com.example.MyClass", result.stack.first().className)
+  }
+
+  @Test
+  fun `handles mixed framework and app code`() {
+    val mixedElements =
+      arrayOf(
+        StackTraceElement("com.example.Activity", "onCreate", "Activity.java", 42),
+        StackTraceElement("com.example.DataProcessor", "process", "DataProcessor.java", 100),
+        StackTraceElement("java.lang.Thread", "run", "Thread.java", 50),
+      )
+    val dumps = listOf(AnrStackTrace(1000, mixedElements))
+
+    val result = AnrCulpritIdentifier.identify(dumps)
+
+    assertNotNull(result)
+    assertEquals(2f / 3f, result.quality, 0.0001f)
+    assertEquals("com.example.Activity", result.stack.first().className)
+  }
+
+  @Test
+  fun `isSystemFrame returns true for java lang packages`() {
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("java.lang.Object"))
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("java.lang.Thread"))
+  }
+
+  @Test
+  fun `isSystemFrame returns true for java util packages`() {
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("java.util.ArrayList"))
+  }
+
+  @Test
+  fun `isSystemFrame returns true for android packages`() {
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("android.app.Activity"))
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("android.os.Handler"))
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("android.os.Looper"))
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("android.view.View"))
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("android.widget.TextView"))
+  }
+
+  @Test
+  fun `isSystemFrame returns true for internal android packages`() {
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("com.android.internal.os.ZygoteInit"))
+    assertEquals(true, AnrCulpritIdentifier.isSystemFrame("com.google.android.gms.common.api.Api"))
+  }
+
+  @Test
+  fun `isSystemFrame returns false for app packages`() {
+    assertEquals(false, AnrCulpritIdentifier.isSystemFrame("com.example.MyClass"))
+    assertEquals(false, AnrCulpritIdentifier.isSystemFrame("io.sentry.samples.MainActivity"))
+    assertEquals(false, AnrCulpritIdentifier.isSystemFrame("org.myapp.Feature"))
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfileManagerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfileManagerTest.kt
new file mode 100644
index 00000000000..09ee720decc
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfileManagerTest.kt
@@ -0,0 +1,137 @@
+package io.sentry.android.core.anr
+
+import io.sentry.SentryOptions
+import java.io.File
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+import org.junit.Rule
+import org.junit.rules.TemporaryFolder
+import org.mockito.kotlin.mock
+
+class AnrProfileManagerTest {
+  @get:Rule val tmpDir = TemporaryFolder()
+
+  private fun createOptions(): SentryOptions {
+    val options = SentryOptions()
+    options.cacheDirPath = tmpDir.newFolder().absolutePath
+    options.setLogger(mock())
+    return options
+  }
+
+  @Test
+  fun `can add and load stack traces`() {
+    // Arrange
+    val options = createOptions()
+    val manager = AnrProfileManager(options)
+    val stackTraceElements =
+      arrayOf(
+        StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42),
+        StackTraceElement("com.example.AnotherClass", "method2", "AnotherClass.java", 100),
+      )
+    val trace = AnrStackTrace(1000, stackTraceElements)
+
+    // Act
+    manager.add(trace)
+    val profile = manager.load()
+
+    // Assert
+    assertNotNull(profile)
+    assertEquals(1, profile.stacks.size)
+    assertEquals(1000L, profile.stacks[0].timestampMs)
+    assertEquals(2, profile.stacks[0].stack.size)
+  }
+
+  @Test
+  fun `can add multiple stack traces`() {
+    // Arrange
+    val options = createOptions()
+    val manager = AnrProfileManager(options)
+    val stackTraceElements1 =
+      arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+    val stackTraceElements2 =
+      arrayOf(StackTraceElement("com.example.AnotherClass", "method2", "AnotherClass.java", 100))
+
+    // Act
+    manager.add(AnrStackTrace(1000, stackTraceElements1))
+    manager.add(AnrStackTrace(2000, stackTraceElements2))
+    val profile = manager.load()
+
+    // Assert
+    assertNotNull(profile)
+    assertEquals(2, profile.stacks.size)
+    assertEquals(1000L, profile.stacks[0].timestampMs)
+    assertEquals(2000L, profile.stacks[1].timestampMs)
+  }
+
+  @Test
+  fun `can clear all stack traces`() {
+    // Arrange
+    val options = createOptions()
+    val manager = AnrProfileManager(options)
+    val stackTraceElements =
+      arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+    manager.add(AnrStackTrace(1000, stackTraceElements))
+
+    // Act
+    manager.clear()
+    val profile = manager.load()
+
+    // Assert
+    assertTrue(profile.stacks.isEmpty())
+  }
+
+  @Test
+  fun `load empty profile when nothing added`() {
+    // Arrange
+    val options = createOptions()
+    val manager = AnrProfileManager(options)
+
+    // Act
+    val profile = manager.load()
+
+    // Assert
+    assertNotNull(profile)
+    assertTrue(profile.stacks.isEmpty())
+  }
+
+  @Test
+  fun `can deal with corrupt files`() {
+    // Arrange
+    val options = createOptions()
+
+    val file = File(options.getCacheDirPath(), "anr_profile")
+    file.writeBytes("Hello World".toByteArray())
+
+    val manager = AnrProfileManager(options)
+
+    // Act
+    val profile = manager.load()
+
+    // Assert
+    assertNotNull(profile)
+    assertTrue(profile.stacks.isEmpty())
+  }
+
+  @Test
+  fun `persists profiles across manager instances`() {
+    // Arrange
+    val options = createOptions()
+    val stackTraceElements =
+      arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+
+    // Act - add profile with first manager
+    var manager = AnrProfileManager(options)
+    manager.add(AnrStackTrace(1000, stackTraceElements))
+
+    // Create new manager instance from same cache dir
+    manager = AnrProfileManager(options)
+    val profile = manager.load()
+
+    // Assert
+    assertNotNull(profile)
+    assertEquals(1, profile.stacks.size)
+    assertEquals(1000L, profile.stacks[0].timestampMs)
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfileRotationHelperTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfileRotationHelperTest.kt
new file mode 100644
index 00000000000..0d7d9556111
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfileRotationHelperTest.kt
@@ -0,0 +1,113 @@
+package io.sentry.android.core.anr
+
+import java.io.File
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+import org.junit.Rule
+import org.junit.rules.TemporaryFolder
+
+class AnrProfileRotationHelperTest {
+  @get:Rule val tmpDir = TemporaryFolder()
+
+  @BeforeTest
+  fun setup() {
+    AnrProfileRotationHelper.rotate()
+  }
+
+  @Test
+  fun `getFileForRecording returns file with correct name`() {
+    val file = AnrProfileRotationHelper.getFileForRecording(tmpDir.root)
+
+    assertEquals("anr_profile", file.name)
+    assertEquals(tmpDir.root, file.parentFile)
+  }
+
+  @Test
+  fun `getLastFile returns last file`() {
+    val file = AnrProfileRotationHelper.getLastFile(tmpDir.root)
+
+    assertEquals("anr_profile_old", file.name)
+    assertEquals(tmpDir.root, file.parentFile)
+  }
+
+  @Test
+  fun `deleteLastFile returns true when file does not exist`() {
+    val result = AnrProfileRotationHelper.deleteLastFile(tmpDir.root)
+
+    assertTrue(result)
+  }
+
+  @Test
+  fun `deleteLastFile returns true when file is deleted successfully`() {
+    val lastFile = File(tmpDir.root, "anr_profile_old")
+    lastFile.writeText("test content")
+    assertTrue(lastFile.exists())
+
+    val result = AnrProfileRotationHelper.deleteLastFile(tmpDir.root)
+
+    assertTrue(result)
+    assertFalse(lastFile.exists())
+  }
+
+  @Test
+  fun `rotate moves current file to last file`() {
+    val currentFile = File(tmpDir.root, "anr_profile")
+    currentFile.writeText("current content")
+
+    val lastFile = AnrProfileRotationHelper.getLastFile(tmpDir.root)
+
+    assertTrue(lastFile.exists())
+    assertEquals("current content", lastFile.readText())
+  }
+
+  @Test
+  fun `rotate deletes existing last file before moving`() {
+    val currentFile = File(tmpDir.root, "anr_profile")
+    val lastFile = File(tmpDir.root, "anr_profile_old")
+
+    lastFile.writeText("last content")
+    currentFile.writeText("current content")
+
+    assertTrue(lastFile.exists())
+    assertTrue(currentFile.exists())
+
+    val newLastFile = AnrProfileRotationHelper.getLastFile(tmpDir.root)
+
+    assertTrue(newLastFile.exists())
+    assertEquals("current content", newLastFile.readText())
+  }
+
+  @Test
+  fun `rotate does not directly perform file renaming`() {
+    val currentFile = File(tmpDir.root, "anr_profile")
+    currentFile.writeText("current")
+
+    val lastFile = File(tmpDir.root, "anr_profile_old")
+    lastFile.writeText("last")
+
+    AnrProfileRotationHelper.rotate()
+
+    // content is still the same
+    assertEquals("current", currentFile.readText())
+    assertEquals("last", lastFile.readText())
+
+    // but once rotated, the last file should now contain the current file's content
+    AnrProfileRotationHelper.getFileForRecording(tmpDir.root)
+    assertEquals("current", lastFile.readText())
+  }
+
+  @Test
+  fun `getFileForRecording triggers rotation when needed`() {
+    val currentFile = File(tmpDir.root, "anr_profile")
+    currentFile.writeText("content before rotation")
+
+    AnrProfileRotationHelper.getFileForRecording(tmpDir.root)
+
+    val lastFile = File(tmpDir.root, "anr_profile_old")
+    assertTrue(lastFile.exists())
+    assertEquals("content before rotation", lastFile.readText())
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt
new file mode 100644
index 00000000000..c07bb4d71bb
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt
@@ -0,0 +1,313 @@
+package io.sentry.android.core.anr
+
+import android.os.SystemClock
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.ILogger
+import io.sentry.IScopes
+import io.sentry.SentryIntegrationPackageStorage
+import io.sentry.SentryOptions
+import io.sentry.android.core.AppState
+import io.sentry.android.core.SentryAndroidOptions
+import io.sentry.test.getProperty
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.junit.Rule
+import org.junit.rules.TemporaryFolder
+import org.junit.runner.RunWith
+import org.mockito.kotlin.mock
+
+@RunWith(AndroidJUnit4::class)
+class AnrProfilingIntegrationTest {
+
+  @get:Rule val tmpDir = TemporaryFolder()
+
+  private lateinit var mockScopes: IScopes
+  private lateinit var mockLogger: ILogger
+  private lateinit var options: SentryAndroidOptions
+
+  @BeforeTest
+  fun setup() {
+    mockScopes = mock()
+    mockLogger = mock()
+    options =
+      SentryAndroidOptions().apply {
+        cacheDirPath = tmpDir.root.absolutePath
+        setLogger(mockLogger)
+        anrProfilingSampleRate = 1.0
+      }
+    AppState.getInstance().resetInstance()
+  }
+
+  @AfterTest
+  fun cleanup() {
+    AppState.getInstance().resetInstance()
+  }
+
+  @Test
+  fun `onForeground starts monitoring thread`() {
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, options)
+
+    integration.onForeground()
+    Thread.sleep(100) // Allow thread to start
+
+    val thread = integration.getProperty<Thread?>("thread")
+    assertNotNull(thread)
+    assertTrue(thread.isAlive)
+    assertEquals("AnrProfilingIntegration", thread.name)
+  }
+
+  @Test
+  fun `onBackground pauses monitoring thread`() {
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, options)
+    integration.onForeground()
+    Thread.sleep(100)
+
+    val thread = integration.getProperty<Thread?>("thread")
+    assertNotNull(thread)
+
+    integration.onBackground()
+    Thread.sleep(200) // Allow thread to enter wait state
+
+    // Thread should still be alive but waiting
+    assertTrue(thread.isAlive)
+
+    integration.close()
+    thread.join(2000)
+    assertFalse(thread.isAlive)
+  }
+
+  @Test
+  fun `close disables integration and interrupts thread`() {
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, options)
+    integration.onForeground()
+    Thread.sleep(100)
+
+    val thread = integration.getProperty<Thread?>("thread")
+    assertNotNull(thread)
+
+    assertTrue(AppState.getInstance().lifecycleObserver.listeners.isNotEmpty())
+
+    integration.close()
+    thread.join(2000)
+
+    assertTrue(!thread.isAlive)
+    val enabled = integration.getProperty<java.util.concurrent.atomic.AtomicBoolean>("enabled")
+    assertTrue(!enabled.get())
+    assertTrue(AppState.getInstance().lifecycleObserver.listeners.isEmpty())
+  }
+
+  @Test
+  fun `lifecycle methods have no influence after close`() {
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, options)
+    integration.close()
+    integration.onForeground()
+    integration.onBackground()
+
+    val thread = integration.getProperty<Thread?>("thread")
+    assertTrue(thread == null || !thread.isAlive)
+  }
+
+  @Test
+  fun `multiple foreground calls do not create multiple threads`() {
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, options)
+
+    integration.onForeground()
+    Thread.sleep(100)
+    val thread1 = integration.getProperty<Thread?>("thread")
+
+    integration.onForeground()
+    Thread.sleep(100)
+    val thread2 = integration.getProperty<Thread?>("thread")
+
+    assertNotNull(thread1)
+    assertNotNull(thread2)
+    assertEquals(thread1, thread2, "Should reuse the same thread")
+
+    integration.close()
+  }
+
+  @Test
+  fun `foreground after background reuses thread`() {
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, options)
+
+    integration.onForeground()
+    Thread.sleep(100)
+    val thread1 = integration.getProperty<Thread?>("thread")
+
+    integration.onBackground()
+    integration.onForeground()
+
+    Thread.sleep(100)
+    val thread2 = integration.getProperty<Thread?>("thread")
+
+    assertNotNull(thread1)
+    assertNotNull(thread2)
+    assertSame(thread1, thread2, "Should reuse the same thread after background")
+    assertTrue(thread1.isAlive)
+
+    integration.close()
+  }
+
+  @Test
+  fun `properly walks through state transitions and collects stack traces`() {
+    val mainThread = Thread.currentThread()
+    SystemClock.setCurrentTimeMillis(1_00)
+
+    val androidOptions =
+      SentryAndroidOptions().apply {
+        cacheDirPath = tmpDir.root.absolutePath
+        setLogger(mockLogger)
+        anrProfilingSampleRate = 1.0
+      }
+
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, androidOptions)
+    integration.onForeground()
+
+    SystemClock.setCurrentTimeMillis(1_000)
+    integration.checkMainThread(mainThread)
+    assertEquals(AnrProfilingIntegration.MainThreadState.IDLE, integration.state)
+    assertTrue(integration.profileManager.load().stacks.isEmpty())
+
+    SystemClock.setCurrentTimeMillis(3_000)
+    integration.checkMainThread(mainThread)
+    assertEquals(AnrProfilingIntegration.MainThreadState.SUSPICIOUS, integration.state)
+
+    SystemClock.setCurrentTimeMillis(6_000)
+    integration.checkMainThread(mainThread)
+    assertEquals(AnrProfilingIntegration.MainThreadState.ANR_DETECTED, integration.state)
+    assertEquals(2, integration.profileManager.load().stacks.size)
+
+    for (i in 0 until AnrProfilingIntegration.MAX_NUM_STACKS + 1) {
+      integration.checkMainThread(mainThread)
+    }
+    assertEquals(AnrProfilingIntegration.MAX_NUM_STACKS, integration.numCollectedStacks.get())
+  }
+
+  @Test
+  fun `background foreground transitions don't trigger an ANR`() {
+    val mainThread = Thread.currentThread()
+    SystemClock.setCurrentTimeMillis(1_000)
+
+    val androidOptions =
+      SentryAndroidOptions().apply {
+        cacheDirPath = tmpDir.root.absolutePath
+        setLogger(mockLogger)
+        anrProfilingSampleRate = 1.0
+      }
+
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, androidOptions)
+    integration.onBackground()
+
+    SystemClock.setCurrentTimeMillis(20_000)
+    integration.onForeground()
+
+    Thread.sleep(100)
+    integration.checkMainThread(mainThread)
+    assertEquals(AnrProfilingIntegration.MainThreadState.IDLE, integration.state)
+  }
+
+  @Test
+  fun `does not register when options is not SentryAndroidOptions`() {
+    val plainOptions =
+      SentryOptions().apply {
+        cacheDirPath = tmpDir.root.absolutePath
+        setLogger(mockLogger)
+      }
+
+    val integration = AnrProfilingIntegration()
+
+    try {
+      integration.register(mockScopes, plainOptions)
+    } catch (e: IllegalArgumentException) {
+      // ignored
+    }
+
+    // Verify no listeners were added
+    val lifecycleObserver = AppState.getInstance().lifecycleObserver
+    if (lifecycleObserver != null) {
+      assertTrue(lifecycleObserver.listeners.isEmpty())
+    }
+  }
+
+  @Test
+  fun `does not register when ANR profiling is disabled`() {
+    val androidOptions =
+      SentryAndroidOptions().apply {
+        cacheDirPath = tmpDir.root.absolutePath
+        setLogger(mockLogger)
+        anrProfilingSampleRate = null
+      }
+
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, androidOptions)
+
+    // When ANR profiling is disabled, the integration doesn't add itself to AppState
+    // So the lifecycle observer may be null or have no listeners
+    val lifecycleObserver = AppState.getInstance().lifecycleObserver
+    if (lifecycleObserver != null) {
+      assertTrue(lifecycleObserver.listeners.isEmpty())
+    }
+  }
+
+  @Test
+  fun `does not collect stacks when sample rate is zero`() {
+    val mainThread = Thread.currentThread()
+    SystemClock.setCurrentTimeMillis(1_00)
+
+    val androidOptions =
+      SentryAndroidOptions().apply {
+        cacheDirPath = tmpDir.root.absolutePath
+        setLogger(mockLogger)
+        anrProfilingSampleRate = 0.0
+      }
+
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, androidOptions)
+    integration.onForeground()
+
+    // Transition to suspicious
+    SystemClock.setCurrentTimeMillis(3_000)
+    integration.checkMainThread(mainThread)
+    assertEquals(AnrProfilingIntegration.MainThreadState.SUSPICIOUS, integration.state)
+
+    // Transition to ANR
+    SystemClock.setCurrentTimeMillis(6_000)
+    integration.checkMainThread(mainThread)
+    assertEquals(AnrProfilingIntegration.MainThreadState.ANR_DETECTED, integration.state)
+
+    // No stacks should have been collected
+    assertEquals(0, integration.numCollectedStacks.get())
+  }
+
+  @Test
+  fun `registers when ANR profiling is enabled`() {
+    val androidOptions =
+      SentryAndroidOptions().apply {
+        cacheDirPath = tmpDir.root.absolutePath
+        setLogger(mockLogger)
+        anrProfilingSampleRate = 1.0
+      }
+
+    val integration = AnrProfilingIntegration()
+    integration.register(mockScopes, androidOptions)
+
+    assertFalse(AppState.getInstance().lifecycleObserver.listeners.isEmpty())
+    assertTrue(SentryIntegrationPackageStorage.getInstance().integrations.contains("AnrProfiling"))
+
+    integration.close()
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceConverterTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceConverterTest.kt
new file mode 100644
index 00000000000..f48f1674166
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceConverterTest.kt
@@ -0,0 +1,197 @@
+package io.sentry.android.core.anr
+
+import org.junit.Assert
+import org.junit.Test
+
+class AnrStackTraceConverterTest {
+  @Test
+  fun testConvertSimpleStackTrace() {
+    val elements =
+      arrayOf(
+        StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42),
+        StackTraceElement("com.example.AnotherClass", "method2", "AnotherClass.java", 100),
+      )
+
+    val anrStackTrace = AnrStackTrace(1000, elements)
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+    anrStackTraces.add(anrStackTrace)
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    Assert.assertNotNull(profile)
+    Assert.assertEquals(1, profile.samples.size)
+    Assert.assertEquals(2, profile.frames.size)
+    Assert.assertEquals(1, profile.stacks.size)
+
+    val frame0 = profile.frames[0]
+    Assert.assertEquals("MyClass.java", frame0.filename)
+    Assert.assertEquals("method1", frame0.function)
+    Assert.assertEquals("com.example.MyClass", frame0.module)
+    Assert.assertEquals(42, frame0.lineno)
+
+    val frame1 = profile.frames[1]
+    Assert.assertEquals("AnotherClass.java", frame1.filename)
+    Assert.assertEquals("method2", frame1.function)
+    Assert.assertEquals("com.example.AnotherClass", frame1.module)
+    Assert.assertEquals(100, frame1.lineno)
+
+    val stack = profile.stacks[0]
+    Assert.assertEquals(2, stack.size)
+    Assert.assertEquals(0, (stack[0] as Int))
+    Assert.assertEquals(1, (stack[1] as Int))
+
+    val sample = profile.samples[0]
+    Assert.assertEquals(0, sample.stackId)
+    Assert.assertEquals("0", sample.threadId)
+    Assert.assertEquals(1.0, sample.timestamp, 0.001) // 1000ms = 1s
+  }
+
+  @Test
+  fun testFrameDeduplication() {
+    // Create two stack traces with duplicate frames
+    val elements1 =
+      arrayOf(
+        StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42),
+        StackTraceElement("com.example.AnotherClass", "method2", "AnotherClass.java", 100),
+      )
+
+    val elements2 =
+      arrayOf(
+        StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42),
+        StackTraceElement("com.example.ThirdClass", "method3", "ThirdClass.java", 200),
+      )
+
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+    anrStackTraces.add(AnrStackTrace(1000, elements1))
+    anrStackTraces.add(AnrStackTrace(2000, elements2))
+
+    // Convert to profile
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    // Should have 3 frames total (dedup removes duplicate)
+    Assert.assertEquals(3, profile.frames.size)
+
+    // First sample uses stack [0, 1]
+    val stack1 = profile.stacks[0]
+    Assert.assertEquals(2, stack1.size)
+    Assert.assertEquals(0, (stack1[0] as Int))
+    Assert.assertEquals(1, (stack1[1] as Int))
+
+    // Second sample uses stack [0, 2] (frame 0 reused)
+    val stack2 = profile.stacks[1]
+    Assert.assertEquals(2, stack2.size)
+    Assert.assertEquals(0, (stack2[0] as Int))
+    Assert.assertEquals(2, (stack2[1] as Int))
+  }
+
+  @Test
+  fun testStackDeduplication() {
+    // Create two stack traces with identical frames in same order
+    val elements =
+      arrayOf(
+        StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42),
+        StackTraceElement("com.example.AnotherClass", "method2", "AnotherClass.java", 100),
+      )
+
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+    anrStackTraces.add(AnrStackTrace(1000, elements))
+    anrStackTraces.add(AnrStackTrace(2000, elements.clone()))
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    // Should have 2 frames and 1 stack (dedup stack)
+    Assert.assertEquals(2, profile.frames.size)
+    Assert.assertEquals(1, profile.stacks.size)
+
+    // Both samples should reference the same stack
+    Assert.assertEquals(0, profile.samples[0].stackId)
+    Assert.assertEquals(0, profile.samples[1].stackId)
+  }
+
+  @Test
+  fun testTimestampConversion() {
+    val elements = arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+
+    val timestampsMs = longArrayOf(1000, 1500, 5000)
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+
+    for (ts in timestampsMs) {
+      anrStackTraces.add(AnrStackTrace(ts, elements))
+    }
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    Assert.assertEquals(1.0, profile.samples[0].timestamp, 0.001)
+    Assert.assertEquals(1.5, profile.samples[1].timestamp, 0.001)
+    Assert.assertEquals(5.0, profile.samples[2].timestamp, 0.001)
+  }
+
+  @Test
+  fun testNativeMethodHandling() {
+    val elements = arrayOf(StackTraceElement("java.lang.System", "doSomething", null, -2))
+
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+    anrStackTraces.add(AnrStackTrace(1000, elements))
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    val frame = profile.frames[0]
+    Assert.assertTrue(frame.isNative()!!)
+  }
+
+  @Test
+  fun testThreadMetadata() {
+    val elements = arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+    anrStackTraces.add(AnrStackTrace(1000, elements))
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    val threadMetadata = profile.threadMetadata["0"]
+    Assert.assertNotNull(threadMetadata)
+    Assert.assertEquals("main", threadMetadata!!.name)
+    Assert.assertEquals(Thread.NORM_PRIORITY, threadMetadata.priority)
+  }
+
+  @Test
+  fun testEmptyStackTraceList() {
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    Assert.assertNotNull(profile)
+    Assert.assertEquals(0, profile.samples.size)
+    Assert.assertEquals(0, profile.frames.size)
+    Assert.assertEquals(0, profile.stacks.size)
+    Assert.assertTrue(profile.threadMetadata.containsKey("0"))
+  }
+
+  @Test
+  fun testSampleProperties() {
+    val elements = arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+    anrStackTraces.add(AnrStackTrace(12345, elements))
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    val sample = profile.samples[0]
+    Assert.assertEquals("0", sample.threadId)
+    Assert.assertEquals(0, sample.stackId)
+    Assert.assertEquals(12.345, sample.timestamp, 0.001)
+  }
+
+  @Test
+  fun testInAppFrameFlag() {
+    val elements = arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+    anrStackTraces.add(AnrStackTrace(1000, elements))
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    val frame = profile.frames[0]
+    Assert.assertNull(frame.isInApp())
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceTest.kt
new file mode 100644
index 00000000000..e53ad507bc1
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceTest.kt
@@ -0,0 +1,127 @@
+package io.sentry.android.core.anr
+
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.DataInputStream
+import java.io.DataOutputStream
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+class AnrStackTraceTest {
+
+  @Test
+  fun `serialize and deserialize preserves stack trace data`() {
+    val stackTraceElements =
+      arrayOf(
+        StackTraceElement("com.example.MyClass", "method1", null, 42),
+        StackTraceElement("com.example.MyClass", "method1", "", 42),
+        StackTraceElement("com.example.AnotherClass", "method2", "AnotherClass.java", 100),
+      )
+    val original = AnrStackTrace(1234567890L, stackTraceElements)
+
+    val bytes = ByteArrayOutputStream()
+    val dos = DataOutputStream(bytes)
+    original.serialize(dos)
+    dos.flush()
+
+    val dis = DataInputStream(ByteArrayInputStream(bytes.toByteArray()))
+    val deserialized = AnrStackTrace.deserialize(dis)
+
+    assertNotNull(deserialized)
+    assertEquals(original.timestampMs, deserialized.timestampMs)
+    assertEquals(original.stack.size, deserialized.stack.size)
+
+    for (i in original.stack.indices) {
+      assertEquals(original.stack[i].className, deserialized.stack[i].className)
+      assertEquals(original.stack[i].methodName, deserialized.stack[i].methodName)
+      assertEquals(original.stack[i].fileName, deserialized.stack[i].fileName)
+      assertEquals(original.stack[i].lineNumber, deserialized.stack[i].lineNumber)
+    }
+  }
+
+  @Test
+  fun `compareTo sorts by timestamp ascending`() {
+    val trace1 = AnrStackTrace(3000L, emptyArray())
+    val trace2 = AnrStackTrace(1000L, emptyArray())
+    val trace3 = AnrStackTrace(2000L, emptyArray())
+
+    val list = listOf(trace3, trace1, trace2)
+    val sorted = list.sorted()
+
+    assertEquals(1000L, sorted[0].timestampMs)
+    assertEquals(2000L, sorted[1].timestampMs)
+    assertEquals(3000L, sorted[2].timestampMs)
+  }
+
+  @Test
+  fun `serialize and deserialize handles empty stack`() {
+    val original = AnrStackTrace(1234567890L, emptyArray())
+
+    val bytes = ByteArrayOutputStream()
+    val dos = DataOutputStream(bytes)
+    original.serialize(dos)
+    dos.flush()
+
+    val dis = DataInputStream(ByteArrayInputStream(bytes.toByteArray()))
+    val deserialized = AnrStackTrace.deserialize(dis)
+
+    assertNotNull(deserialized)
+    assertEquals(0, deserialized.stack.size)
+    assertEquals(original.timestampMs, deserialized.timestampMs)
+  }
+
+  @Test
+  fun `serialize and deserialize handles native methods with no line number`() {
+    val stackTraceElements =
+      arrayOf(
+        StackTraceElement("java.lang.reflect.Method", "invoke", null, -2),
+        StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42),
+      )
+    val original = AnrStackTrace(1234567890L, stackTraceElements)
+
+    val bytes = ByteArrayOutputStream()
+    val dos = DataOutputStream(bytes)
+    original.serialize(dos)
+    dos.flush()
+
+    val dis = DataInputStream(ByteArrayInputStream(bytes.toByteArray()))
+    val deserialized = AnrStackTrace.deserialize(dis)
+
+    assertNotNull(deserialized)
+    assertEquals(-2, deserialized.stack[0].lineNumber)
+    assertNull(deserialized.stack[0].fileName)
+    assertEquals(42, deserialized.stack[1].lineNumber)
+  }
+
+  @Test
+  fun `deserialize returns null for oversized stack length`() {
+    val bytes = ByteArrayOutputStream()
+    val dos = DataOutputStream(bytes)
+    dos.writeShort(1) // version
+    dos.writeLong(1234567890L) // timestamp
+    dos.writeInt(1001) // stackLength exceeds MAX_STACK_LENGTH
+    dos.flush()
+
+    val dis = DataInputStream(ByteArrayInputStream(bytes.toByteArray()))
+    val deserialized = AnrStackTrace.deserialize(dis)
+
+    assertNull(deserialized)
+  }
+
+  @Test
+  fun `deserialize returns null for negative stack length`() {
+    val bytes = ByteArrayOutputStream()
+    val dos = DataOutputStream(bytes)
+    dos.writeShort(1) // version
+    dos.writeLong(1234567890L) // timestamp
+    dos.writeInt(-1) // negative stackLength
+    dos.flush()
+
+    val dis = DataInputStream(ByteArrayInputStream(bytes.toByteArray()))
+    val deserialized = AnrStackTrace.deserialize(dis)
+
+    assertNull(deserialized)
+  }
+}
diff --git a/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt b/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt
index e15347095f6..89013c430dd 100644
--- a/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt
+++ b/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt
@@ -1,5 +1,6 @@
 package io.sentry.android.distribution
 
+import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.SentryOptions
 import io.sentry.UpdateStatus
 import org.junit.Assert.assertEquals
@@ -7,9 +8,8 @@ import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.robolectric.RobolectricTestRunner
 
-@RunWith(RobolectricTestRunner::class)
+@RunWith(AndroidJUnit4::class)
 class UpdateResponseParserTest {
 
   private lateinit var options: SentryOptions
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 690401e44e3..d73a3150f0a 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -253,7 +253,7 @@
     <meta-data
       android:name="io.sentry.session-replay.network-response-headers"
       android:value="X-Response-Time,X-Cache-Status,X-Test-Response" />
-    <meta-data 
+    <meta-data
       android:name="io.sentry.spotlight.enable"
       android:value="true" />
     <meta-data
@@ -265,5 +265,11 @@
     <meta-data
       android:name="io.sentry.tombstone.enable"
       android:value="true" />
+    <meta-data
+      android:name="io.sentry.anr.profiling.sample-rate"
+      android:value="1.0" />
+    <meta-data
+      android:name="io.sentry.anr.enable-fingerprinting"
+      android:value="true" />
   </application>
 </manifest>
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index c8b194f32d3..0b8171da631 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -7757,6 +7757,7 @@ public final class io/sentry/util/StringUtils {
 	public static fun camelCase (Ljava/lang/String;)Ljava/lang/String;
 	public static fun capitalize (Ljava/lang/String;)Ljava/lang/String;
 	public static fun countOf (Ljava/lang/String;C)I
+	public static fun getOrEmpty (Ljava/lang/String;)Ljava/lang/String;
 	public static fun getStringAfterDot (Ljava/lang/String;)Ljava/lang/String;
 	public static fun join (Ljava/lang/CharSequence;Ljava/lang/Iterable;)Ljava/lang/String;
 	public static fun normalizeUUID (Ljava/lang/String;)Ljava/lang/String;
diff --git a/sentry/src/main/java/io/sentry/ProfileChunk.java b/sentry/src/main/java/io/sentry/ProfileChunk.java
index 0aa6b7e524d..a6145ca8e9a 100644
--- a/sentry/src/main/java/io/sentry/ProfileChunk.java
+++ b/sentry/src/main/java/io/sentry/ProfileChunk.java
@@ -34,7 +34,7 @@ public final class ProfileChunk implements JsonUnknown, JsonSerializable {
   private @NotNull String version;
   private double timestamp;
 
-  private final @NotNull File traceFile;
+  private final @Nullable File traceFile;
 
   /** Profile trace encoded with Base64. */
   private @Nullable String sampledProfile = null;
@@ -47,7 +47,7 @@ public ProfileChunk() {
     this(
         SentryId.EMPTY_ID,
         SentryId.EMPTY_ID,
-        new File("dummy"),
+        null,
         new HashMap<>(),
         0.0,
         PLATFORM_ANDROID,
@@ -57,7 +57,7 @@ public ProfileChunk() {
   public ProfileChunk(
       final @NotNull SentryId profilerId,
       final @NotNull SentryId chunkId,
-      final @NotNull File traceFile,
+      final @Nullable File traceFile,
       final @NotNull Map<String, ProfileMeasurement> measurements,
       final @NotNull Double timestamp,
       final @NotNull String platform,
@@ -119,7 +119,7 @@ public void setSampledProfile(final @Nullable String sampledProfile) {
     this.sampledProfile = sampledProfile;
   }
 
-  public @NotNull File getTraceFile() {
+  public @Nullable File getTraceFile() {
     return traceFile;
   }
 
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
index 58d150886d3..dd47d2b99d0 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
@@ -302,42 +302,44 @@ private static void ensureAttachmentSizeLimit(
       final @NotNull IProfileConverter profileConverter)
       throws SentryEnvelopeException {
 
-    final @NotNull File traceFile = profileChunk.getTraceFile();
+    final @Nullable File traceFile = profileChunk.getTraceFile();
     // Using CachedItem, so we read the trace file in the background
     final CachedItem cachedItem =
         new CachedItem(
             () -> {
-              if (!traceFile.exists()) {
-                throw new SentryEnvelopeException(
-                    String.format(
-                        "Dropping profile chunk, because the file '%s' doesn't exists",
-                        traceFile.getName()));
-              }
+              if (traceFile != null) {
+                if (!traceFile.exists()) {
+                  throw new SentryEnvelopeException(
+                      String.format(
+                          "Dropping profile chunk, because the file '%s' doesn't exists",
+                          traceFile.getName()));
+                }
 
-              if (ProfileChunk.PLATFORM_JAVA.equals(profileChunk.getPlatform())) {
-                if (!NoOpProfileConverter.getInstance().equals(profileConverter)) {
-                  try {
-                    final SentryProfile profile =
-                        profileConverter.convertFromFile(traceFile.getAbsolutePath());
-                    profileChunk.setSentryProfile(profile);
-                  } catch (Exception e) {
-                    throw new SentryEnvelopeException("Profile conversion failed", e);
+                if (ProfileChunk.PLATFORM_JAVA.equals(profileChunk.getPlatform())) {
+                  if (!NoOpProfileConverter.getInstance().equals(profileConverter)) {
+                    try {
+                      final SentryProfile profile =
+                          profileConverter.convertFromFile(traceFile.getAbsolutePath());
+                      profileChunk.setSentryProfile(profile);
+                    } catch (Exception e) {
+                      throw new SentryEnvelopeException("Profile conversion failed", e);
+                    }
+                  } else {
+                    throw new SentryEnvelopeException(
+                        "No ProfileConverter available, dropping chunk.");
                   }
                 } else {
-                  throw new SentryEnvelopeException(
-                      "No ProfileConverter available, dropping chunk.");
-                }
-              } else {
-                // The payload of the profile item is a json including the trace file encoded with
-                // base64
-                final byte[] traceFileBytes =
-                    readBytesFromFile(traceFile.getPath(), MAX_PROFILE_CHUNK_SIZE);
-                final @NotNull String base64Trace =
-                    Base64.encodeToString(traceFileBytes, NO_WRAP | NO_PADDING);
-                if (base64Trace.isEmpty()) {
-                  throw new SentryEnvelopeException("Profiling trace file is empty");
+                  // The payload of the profile item is a json including the trace file encoded with
+                  // base64
+                  final byte[] traceFileBytes =
+                      readBytesFromFile(traceFile.getPath(), MAX_PROFILE_CHUNK_SIZE);
+                  final @NotNull String base64Trace =
+                      Base64.encodeToString(traceFileBytes, NO_WRAP | NO_PADDING);
+                  if (base64Trace.isEmpty()) {
+                    throw new SentryEnvelopeException("Profiling trace file is empty");
+                  }
+                  profileChunk.setSampledProfile(base64Trace);
                 }
-                profileChunk.setSampledProfile(base64Trace);
               }
 
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
@@ -349,7 +351,9 @@ private static void ensureAttachmentSizeLimit(
                     String.format("Failed to serialize profile chunk\n%s", e.getMessage()));
               } finally {
                 // In any case we delete the trace file
-                traceFile.delete();
+                if (traceFile != null) {
+                  traceFile.delete();
+                }
               }
             });
 
@@ -358,7 +362,7 @@ private static void ensureAttachmentSizeLimit(
             SentryItemType.ProfileChunk,
             () -> cachedItem.getBytes().length,
             "application-json",
-            traceFile.getName(),
+            traceFile != null ? traceFile.getName() : null,
             null,
             profileChunk.getPlatform(),
             null);
diff --git a/sentry/src/main/java/io/sentry/SentryExceptionFactory.java b/sentry/src/main/java/io/sentry/SentryExceptionFactory.java
index d47776a1627..cd4ab1cc0e9 100644
--- a/sentry/src/main/java/io/sentry/SentryExceptionFactory.java
+++ b/sentry/src/main/java/io/sentry/SentryExceptionFactory.java
@@ -172,9 +172,9 @@ Deque<SentryException> extractExceptionQueueInternal(
       final List<SentryStackFrame> frames =
           sentryStackTraceFactory.getStackFrames(
               currentThrowable.getStackTrace(), includeSentryFrames);
+      final @Nullable Long threadId = thread != null ? thread.getId() : null;
       SentryException exception =
-          getSentryException(
-              currentThrowable, exceptionMechanism, thread.getId(), frames, snapshot);
+          getSentryException(currentThrowable, exceptionMechanism, threadId, frames, snapshot);
       exceptions.addFirst(exception);
 
       if (exceptionMechanism.getType() == null) {
diff --git a/sentry/src/main/java/io/sentry/exception/ExceptionMechanismException.java b/sentry/src/main/java/io/sentry/exception/ExceptionMechanismException.java
index 5cfeb747dd2..5df6d473f78 100644
--- a/sentry/src/main/java/io/sentry/exception/ExceptionMechanismException.java
+++ b/sentry/src/main/java/io/sentry/exception/ExceptionMechanismException.java
@@ -4,6 +4,7 @@
 import io.sentry.util.Objects;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 /**
  * A throwable decorator that holds an {@link io.sentry.protocol.Mechanism} related to the decorated
@@ -15,7 +16,7 @@ public final class ExceptionMechanismException extends RuntimeException {
 
   private final @NotNull Mechanism exceptionMechanism;
   private final @NotNull Throwable throwable;
-  private final @NotNull Thread thread;
+  private final @Nullable Thread thread;
   private final boolean snapshot;
 
   /**
@@ -29,11 +30,11 @@ public final class ExceptionMechanismException extends RuntimeException {
   public ExceptionMechanismException(
       final @NotNull Mechanism mechanism,
       final @NotNull Throwable throwable,
-      final @NotNull Thread thread,
+      final @Nullable Thread thread,
       final boolean snapshot) {
     exceptionMechanism = Objects.requireNonNull(mechanism, "Mechanism is required.");
     this.throwable = Objects.requireNonNull(throwable, "Throwable is required.");
-    this.thread = Objects.requireNonNull(thread, "Thread is required.");
+    this.thread = thread;
     this.snapshot = snapshot;
   }
 
@@ -47,7 +48,7 @@ public ExceptionMechanismException(
   public ExceptionMechanismException(
       final @NotNull Mechanism mechanism,
       final @NotNull Throwable throwable,
-      final @NotNull Thread thread) {
+      final @Nullable Thread thread) {
     this(mechanism, throwable, thread, false);
   }
 
@@ -74,7 +75,7 @@ public ExceptionMechanismException(
    *
    * @return the Thread
    */
-  public @NotNull Thread getThread() {
+  public @Nullable Thread getThread() {
     return thread;
   }
 
diff --git a/sentry/src/main/java/io/sentry/util/StringUtils.java b/sentry/src/main/java/io/sentry/util/StringUtils.java
index 14c247e71d2..66e3a95ddb7 100644
--- a/sentry/src/main/java/io/sentry/util/StringUtils.java
+++ b/sentry/src/main/java/io/sentry/util/StringUtils.java
@@ -26,6 +26,14 @@ public final class StringUtils {
 
   private StringUtils() {}
 
+  public static @NotNull String getOrEmpty(final @Nullable String str) {
+    if (str == null) {
+      return "";
+    } else {
+      return str;
+    }
+  }
+
   public static @Nullable String getStringAfterDot(final @Nullable String str) {
     if (str != null) {
       final int lastDotIndex = str.lastIndexOf(".");

From dde4bad1b0d838086a9d0b949f782b79c3268a85 Mon Sep 17 00:00:00 2001
From: Lorenzo Cian <17258265+lcian@users.noreply.github.com>
Date: Mon, 9 Mar 2026 12:23:19 +0100
Subject: [PATCH 040/391] meta(gh): Remove myself from CODEOWNERS (#5177)

---
 .github/CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index b01358a8742..4a3ed92029f 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1 +1 @@
-*       @adinauer @romtsn @markushi @lcian
+*       @adinauer @romtsn @markushi

From 08ffa5a5299b9de520ca5bf6b0b5c19afa5634e8 Mon Sep 17 00:00:00 2001
From: Mischan Toosarani-Hausberger <mischan@abovevacant.com>
Date: Mon, 9 Mar 2026 13:07:12 +0100
Subject: [PATCH 041/391] fix: remove the dependency on protobuf-lite for
 tombstones (#5157)

* fix: remove the dependency on protobuf-lite for tombstones

* update changelog

* gate the close() on the underlying input stream

* add scheduled GHA workflow to check for changes in the tombstone protobuf schema
---
 .../check-tombstone-proto-schema.yml          |  16 +
 CHANGELOG.md                                  |   1 +
 gradle/libs.versions.toml                     |   5 +-
 scripts/check-tombstone-proto-schema.sh       |  25 ++
 sentry-android-core/build.gradle.kts          |  10 +-
 sentry-android-core/proguard-rules.pro        |   3 -
 .../internal/tombstone/TombstoneParser.java   | 138 ++++---
 .../core/internal/tombstone/tombstone.proto   | 218 -----------
 .../internal/tombstone/TombstoneParserTest.kt | 356 +++++++++---------
 9 files changed, 294 insertions(+), 478 deletions(-)
 create mode 100644 .github/workflows/check-tombstone-proto-schema.yml
 create mode 100755 scripts/check-tombstone-proto-schema.sh
 delete mode 100644 sentry-android-core/src/main/proto/io/sentry/android/core/internal/tombstone/tombstone.proto

diff --git a/.github/workflows/check-tombstone-proto-schema.yml b/.github/workflows/check-tombstone-proto-schema.yml
new file mode 100644
index 00000000000..9234be0c429
--- /dev/null
+++ b/.github/workflows/check-tombstone-proto-schema.yml
@@ -0,0 +1,16 @@
+name: Check Tombstone Proto Schema
+
+on:
+  schedule:
+    - cron: '0 9 * * *'
+  workflow_dispatch:
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Check for newer Tombstone proto schema
+        run: ./scripts/check-tombstone-proto-schema.sh
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 503d58a4eda..21fcd2aac74 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@
 - Common: Finalize previous session even when auto session tracking is disabled ([#5154](https://github.com/getsentry/sentry-java/pull/5154))
 - Android: Add `filterTouchesWhenObscured` to prevent Tapjacking on user feedback dialog ([#5155](https://github.com/getsentry/sentry-java/pull/5155))
 - Android: Add proguard rules to prevent error about missing Replay classes ([#5153](https://github.com/getsentry/sentry-java/pull/5153))
+- Android: Remove the dependency on protobuf-lite for tombstones ([#5157](https://github.com/getsentry/sentry-java/pull/5157))
 
 ## 8.34.0
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index dd2a471f695..61fbefd9152 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -41,7 +41,6 @@ spotless = "7.0.4"
 gummyBears = "0.12.0"
 camerax = "1.3.0"
 openfeature = "1.18.2"
-protobuf = "3.25.8"
 
 [plugins]
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
@@ -61,7 +60,6 @@ spotless = { id = "com.diffplug.spotless", version.ref = "spotless" }
 detekt = { id = "io.gitlab.arturbosch.detekt", version = "1.23.8" }
 jacoco-android = { id = "com.mxalbert.gradle.jacoco-android", version = "0.2.0" }
 kover = { id = "org.jetbrains.kotlinx.kover", version = "0.7.3" }
-protobuf = { id = "com.google.protobuf", version = "0.9.5" }
 vanniktech-maven-publish = { id = "com.vanniktech.maven.publish", version = "0.30.0" }
 springboot2 = { id = "org.springframework.boot", version.ref = "springboot2" }
 springboot3 = { id = "org.springframework.boot", version.ref = "springboot3" }
@@ -145,8 +143,7 @@ otel-javaagent-extension-api = { module = "io.opentelemetry.javaagent:openteleme
 otel-semconv = { module = "io.opentelemetry.semconv:opentelemetry-semconv", version.ref = "otelSemanticConventions" }
 otel-semconv-incubating = { module = "io.opentelemetry.semconv:opentelemetry-semconv-incubating", version.ref = "otelSemanticConventionsAlpha" }
 p6spy = { module = "p6spy:p6spy", version = "3.9.1" }
-protobuf-javalite = { module = "com.google.protobuf:protobuf-javalite", version.ref = "protobuf"}
-protoc = { module = "com.google.protobuf:protoc", version.ref = "protobuf" }
+epitaph = { module = "com.abovevacant:epitaph", version = "0.1.0" }
 quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
diff --git a/scripts/check-tombstone-proto-schema.sh b/scripts/check-tombstone-proto-schema.sh
new file mode 100755
index 00000000000..abb7212c4af
--- /dev/null
+++ b/scripts/check-tombstone-proto-schema.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+TRACKED_COMMIT="981d145117e8992842cdddee555c57e60c7a220a"
+
+# tail -n +2 to remove the magic anti-XSSI prefix from the Gitiles JSON response
+LATEST_COMMIT=$(curl -sf \
+  'https://android.googlesource.com/platform/system/core/+log/refs/heads/main/debuggerd/proto/tombstone.proto?format=JSON' \
+  | tail -n +2 \
+  | jq -r '.log[0].commit')
+
+if [ -z "$LATEST_COMMIT" ] || [ "$LATEST_COMMIT" = "null" ]; then
+  echo "ERROR: Failed to fetch latest commit from Gitiles" >&2
+  exit 1
+fi
+
+echo "Tracked commit: $TRACKED_COMMIT"
+echo "Latest commit:  $LATEST_COMMIT"
+
+if [ "$LATEST_COMMIT" != "$TRACKED_COMMIT" ]; then
+  echo "Schema has been updated! Latest: https://android.googlesource.com/platform/system/core/+/${LATEST_COMMIT}/debuggerd/proto/tombstone.proto"
+  exit 1
+fi
+
+echo "Schema is up to date."
diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index 23dc964d3d6..1134e948226 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -8,7 +8,6 @@ plugins {
   alias(libs.plugins.jacoco.android)
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
-  alias(libs.plugins.protobuf)
 }
 
 android {
@@ -84,7 +83,7 @@ dependencies {
   implementation(libs.androidx.lifecycle.common.java8)
   implementation(libs.androidx.lifecycle.process)
   implementation(libs.androidx.core)
-  implementation(libs.protobuf.javalite)
+  implementation(libs.epitaph)
 
   errorprone(libs.errorprone.core)
   errorprone(libs.nopen.checker)
@@ -113,10 +112,3 @@ dependencies {
   testRuntimeOnly(libs.androidx.fragment.ktx)
   testRuntimeOnly(libs.timber)
 }
-
-protobuf {
-  protoc { artifact = libs.protoc.get().toString() }
-  generateProtoTasks {
-    all().forEach { task -> task.builtins { create("java") { option("lite") } } }
-  }
-}
diff --git a/sentry-android-core/proguard-rules.pro b/sentry-android-core/proguard-rules.pro
index 2b49c949db9..aca674442bf 100644
--- a/sentry-android-core/proguard-rules.pro
+++ b/sentry-android-core/proguard-rules.pro
@@ -54,9 +54,6 @@
 
 -keepnames class io.sentry.android.core.ApplicationNotResponding
 
-# protobuf-java lite
-# https://github.com/protocolbuffers/protobuf/blob/5d876c9fec1a6f2feb0750694f803f89312bffff/java/lite.md#r8-rule-to-make-production-app-builds-work
--keep class * extends com.google.protobuf.GeneratedMessageLite { *; }
 
 ##---------------End: proguard configuration for android-core  ----------
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java
index 3235b566556..1f142b52c9a 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java
@@ -1,6 +1,13 @@
 package io.sentry.android.core.internal.tombstone;
 
 import androidx.annotation.NonNull;
+import com.abovevacant.epitaph.core.BacktraceFrame;
+import com.abovevacant.epitaph.core.MemoryMapping;
+import com.abovevacant.epitaph.core.Register;
+import com.abovevacant.epitaph.core.Signal;
+import com.abovevacant.epitaph.core.Tombstone;
+import com.abovevacant.epitaph.core.TombstoneThread;
+import com.abovevacant.epitaph.wire.TombstoneDecoder;
 import io.sentry.SentryEvent;
 import io.sentry.SentryLevel;
 import io.sentry.SentryStackTraceFactory;
@@ -27,7 +34,7 @@
 
 public class TombstoneParser implements Closeable {
 
-  private final InputStream tombstoneStream;
+  @Nullable private final InputStream tombstoneStream;
   @NotNull private final List<String> inAppIncludes;
   @NotNull private final List<String> inAppExcludes;
   @Nullable private final String nativeLibraryDir;
@@ -38,7 +45,14 @@ private static String formatHex(long value) {
   }
 
   public TombstoneParser(
-      @NonNull final InputStream tombstoneStream,
+      @NotNull List<String> inAppIncludes,
+      @NotNull List<String> inAppExcludes,
+      @Nullable String nativeLibraryDir) {
+    this(null, inAppIncludes, inAppExcludes, nativeLibraryDir);
+  }
+
+  public TombstoneParser(
+      @Nullable final InputStream tombstoneStream,
       @NotNull List<String> inAppIncludes,
       @NotNull List<String> inAppExcludes,
       @Nullable String nativeLibraryDir) {
@@ -58,10 +72,14 @@ public TombstoneParser(
 
   @NonNull
   public SentryEvent parse() throws IOException {
-    @NonNull
-    final TombstoneProtos.Tombstone tombstone =
-        TombstoneProtos.Tombstone.parseFrom(tombstoneStream);
+    if (tombstoneStream == null) {
+      throw new IOException("No InputStream provided; use parse(Tombstone) instead.");
+    }
+    return parse(TombstoneDecoder.decode(tombstoneStream));
+  }
 
+  @NonNull
+  public SentryEvent parse(@NonNull final Tombstone tombstone) {
     final SentryEvent event = new SentryEvent();
     event.setLevel(SentryLevel.FATAL);
 
@@ -79,19 +97,18 @@ public SentryEvent parse() throws IOException {
 
   @NonNull
   private List<SentryThread> createThreads(
-      @NonNull final TombstoneProtos.Tombstone tombstone, @NonNull final SentryException exc) {
+      @NonNull final Tombstone tombstone, @NonNull final SentryException exc) {
     final List<SentryThread> threads = new ArrayList<>();
-    for (Map.Entry<Integer, TombstoneProtos.Thread> threadEntry :
-        tombstone.getThreadsMap().entrySet()) {
-      final TombstoneProtos.Thread threadEntryValue = threadEntry.getValue();
+    for (Map.Entry<Integer, TombstoneThread> threadEntry : tombstone.threads.entrySet()) {
+      final TombstoneThread threadEntryValue = threadEntry.getValue();
 
       final SentryThread thread = new SentryThread();
       thread.setId(Long.valueOf(threadEntry.getKey()));
-      thread.setName(threadEntryValue.getName());
+      thread.setName(threadEntryValue.name);
 
       final SentryStackTrace stacktrace = createStackTrace(threadEntryValue);
       thread.setStacktrace(stacktrace);
-      if (tombstone.getTid() == threadEntryValue.getId()) {
+      if (tombstone.tid == threadEntryValue.id) {
         thread.setCrashed(true);
         // even though we refer to the thread_id from the exception,
         // the backend currently requires a stack-trace in exception
@@ -104,30 +121,30 @@ private List<SentryThread> createThreads(
   }
 
   @NonNull
-  private SentryStackTrace createStackTrace(@NonNull final TombstoneProtos.Thread thread) {
+  private SentryStackTrace createStackTrace(@NonNull final TombstoneThread thread) {
     final List<SentryStackFrame> frames = new ArrayList<>();
 
-    for (TombstoneProtos.BacktraceFrame frame : thread.getCurrentBacktraceList()) {
-      if (frame.getFileName().endsWith("libart.so")) {
+    for (BacktraceFrame frame : thread.backtrace) {
+      if (frame.fileName.endsWith("libart.so")) {
         // We ignore all ART frames for time being because they aren't actionable for app developers
         continue;
       }
-      if (frame.getFileName().startsWith("<anonymous") && frame.getFunctionName().isEmpty()) {
+      if (frame.fileName.startsWith("<anonymous") && frame.functionName.isEmpty()) {
         // Code in anonymous VMAs that does not resolve to a function name, cannot be symbolicated
         // in the backend either, and thus has no value in the UI.
         continue;
       }
       final SentryStackFrame stackFrame = new SentryStackFrame();
-      stackFrame.setPackage(frame.getFileName());
-      stackFrame.setFunction(frame.getFunctionName());
-      stackFrame.setInstructionAddr(formatHex(frame.getPc()));
+      stackFrame.setPackage(frame.fileName);
+      stackFrame.setFunction(frame.functionName);
+      stackFrame.setInstructionAddr(formatHex(frame.pc));
 
       // inAppIncludes/inAppExcludes filter by Java/Kotlin package names, which don't overlap
       // with native C/C++ function names (e.g., "crash", "__libc_init"). For native frames,
       // isInApp() returns null, making nativeLibraryDir the effective in-app check.
-      // Protobuf returns "" for unset function names, which would incorrectly return true
+      // epitaph returns "" for unset function names, which would incorrectly return true
       // from isInApp(), so we treat empty as false to let nativeLibraryDir decide.
-      final String functionName = frame.getFunctionName();
+      final String functionName = frame.functionName;
       @Nullable
       Boolean inApp =
           functionName.isEmpty()
@@ -135,7 +152,7 @@ private SentryStackTrace createStackTrace(@NonNull final TombstoneProtos.Thread
               : SentryStackTraceFactory.isInApp(functionName, inAppIncludes, inAppExcludes);
 
       final boolean isInNativeLibraryDir =
-          nativeLibraryDir != null && frame.getFileName().startsWith(nativeLibraryDir);
+          nativeLibraryDir != null && frame.fileName.startsWith(nativeLibraryDir);
       inApp = (inApp != null && inApp) || isInNativeLibraryDir;
 
       stackFrame.setInApp(inApp);
@@ -151,8 +168,8 @@ private SentryStackTrace createStackTrace(@NonNull final TombstoneProtos.Thread
     stacktrace.setInstructionAddressAdjustment(SentryStackTrace.InstructionAddressAdjustment.NONE);
 
     final Map<String, String> registers = new HashMap<>();
-    for (TombstoneProtos.Register register : thread.getRegistersList()) {
-      registers.put(register.getName(), formatHex(register.getU64()));
+    for (Register register : thread.registers) {
+      registers.put(register.name, formatHex(register.value));
     }
     stacktrace.setRegisters(registers);
 
@@ -160,17 +177,17 @@ private SentryStackTrace createStackTrace(@NonNull final TombstoneProtos.Thread
   }
 
   @NonNull
-  private List<SentryException> createException(@NonNull TombstoneProtos.Tombstone tombstone) {
+  private List<SentryException> createException(@NonNull Tombstone tombstone) {
     final SentryException exception = new SentryException();
 
-    if (tombstone.hasSignalInfo()) {
-      final TombstoneProtos.Signal signalInfo = tombstone.getSignalInfo();
-      exception.setType(signalInfo.getName());
-      exception.setValue(excTypeValueMap.get(signalInfo.getName()));
+    if (tombstone.hasSignal()) {
+      final Signal signalInfo = tombstone.signal;
+      exception.setType(signalInfo.name);
+      exception.setValue(excTypeValueMap.get(signalInfo.name));
       exception.setMechanism(createMechanismFromSignalInfo(signalInfo));
     }
 
-    exception.setThreadId((long) tombstone.getTid());
+    exception.setThreadId((long) tombstone.tid);
     final List<SentryException> exceptions = new ArrayList<>(1);
     exceptions.add(exception);
 
@@ -178,8 +195,7 @@ private List<SentryException> createException(@NonNull TombstoneProtos.Tombstone
   }
 
   @NonNull
-  private static Mechanism createMechanismFromSignalInfo(
-      @NonNull final TombstoneProtos.Signal signalInfo) {
+  private static Mechanism createMechanismFromSignalInfo(@NonNull final Signal signalInfo) {
 
     final Mechanism mechanism = new Mechanism();
     mechanism.setType(NativeExceptionMechanism.TOMBSTONE.getValue());
@@ -187,38 +203,38 @@ private static Mechanism createMechanismFromSignalInfo(
     mechanism.setSynthetic(true);
 
     final Map<String, Object> meta = new HashMap<>();
-    meta.put("number", signalInfo.getNumber());
-    meta.put("name", signalInfo.getName());
-    meta.put("code", signalInfo.getCode());
-    meta.put("code_name", signalInfo.getCodeName());
+    meta.put("number", signalInfo.number);
+    meta.put("name", signalInfo.name);
+    meta.put("code", signalInfo.code);
+    meta.put("code_name", signalInfo.codeName);
     mechanism.setMeta(meta);
 
     return mechanism;
   }
 
   @NonNull
-  private Message constructMessage(@NonNull final TombstoneProtos.Tombstone tombstone) {
+  private Message constructMessage(@NonNull final Tombstone tombstone) {
     final Message message = new Message();
-    final TombstoneProtos.Signal signalInfo = tombstone.getSignalInfo();
+    final Signal signalInfo = tombstone.signal;
 
     // reproduce the message `debuggerd` would use to dump the stack trace in logcat
-    String command = String.join(" ", tombstone.getCommandLineList());
-    if (tombstone.hasSignalInfo()) {
-      String abortMessage = tombstone.getAbortMessage();
+    String command = String.join(" ", tombstone.commandLine);
+    if (tombstone.hasSignal()) {
+      String abortMessage = tombstone.abortMessage;
       message.setFormatted(
           String.format(
               Locale.ROOT,
               "%sFatal signal %s (%d), %s (%d), pid = %d (%s)",
               !abortMessage.isEmpty() ? abortMessage + ": " : "",
-              signalInfo.getName(),
-              signalInfo.getNumber(),
-              signalInfo.getCodeName(),
-              signalInfo.getCode(),
-              tombstone.getPid(),
+              signalInfo.name,
+              signalInfo.number,
+              signalInfo.codeName,
+              signalInfo.code,
+              tombstone.pid,
               command));
     } else {
       message.setFormatted(
-          String.format(Locale.ROOT, "Fatal exit pid = %d (%s)", tombstone.getPid(), command));
+          String.format(Locale.ROOT, "Fatal exit pid = %d (%s)", tombstone.pid, command));
     }
 
     return message;
@@ -236,11 +252,11 @@ private static class ModuleAccumulator {
     long beginAddress;
     long endAddress;
 
-    ModuleAccumulator(TombstoneProtos.MemoryMapping mapping) {
-      this.mappingName = mapping.getMappingName();
-      this.buildId = mapping.getBuildId();
-      this.beginAddress = mapping.getBeginAddress();
-      this.endAddress = mapping.getEndAddress();
+    ModuleAccumulator(MemoryMapping mapping) {
+      this.mappingName = mapping.mappingName;
+      this.buildId = mapping.buildId;
+      this.beginAddress = mapping.beginAddress;
+      this.endAddress = mapping.endAddress;
     }
 
     void extendTo(long newEndAddress) {
@@ -266,7 +282,7 @@ DebugImage toDebugImage() {
     }
   }
 
-  private DebugMeta createDebugMeta(@NonNull final TombstoneProtos.Tombstone tombstone) {
+  private DebugMeta createDebugMeta(@NonNull final Tombstone tombstone) {
     final List<DebugImage> images = new ArrayList<>();
 
     // Coalesce memory mappings into modules similar to how sentry-native does it.
@@ -277,27 +293,27 @@ private DebugMeta createDebugMeta(@NonNull final TombstoneProtos.Tombstone tombs
     // combined with non-empty build_id as a proxy for this check.
     ModuleAccumulator currentModule = null;
 
-    for (TombstoneProtos.MemoryMapping mapping : tombstone.getMemoryMappingsList()) {
+    for (MemoryMapping mapping : tombstone.memoryMappings) {
       // Skip mappings that are not readable
-      if (!mapping.getRead()) {
+      if (!mapping.read) {
         continue;
       }
 
       // Skip mappings with empty name or in /dev/
-      final String mappingName = mapping.getMappingName();
+      final String mappingName = mapping.mappingName;
       if (mappingName.isEmpty() || mappingName.startsWith("/dev/")) {
         continue;
       }
 
-      final boolean hasBuildId = !mapping.getBuildId().isEmpty();
-      final boolean isFileStart = mapping.getOffset() == 0;
+      final boolean hasBuildId = !mapping.buildId.isEmpty();
+      final boolean isFileStart = mapping.offset == 0;
 
       if (hasBuildId && isFileStart) {
         // Check for duplicated mappings: On Android, the same ELF can have multiple
         // mappings at offset 0 with different permissions (r--p, r-xp, r--p).
         // If it's the same file as the current module, just extend it.
         if (currentModule != null && mappingName.equals(currentModule.mappingName)) {
-          currentModule.extendTo(mapping.getEndAddress());
+          currentModule.extendTo(mapping.endAddress);
           continue;
         }
 
@@ -313,7 +329,7 @@ private DebugMeta createDebugMeta(@NonNull final TombstoneProtos.Tombstone tombs
         currentModule = new ModuleAccumulator(mapping);
       } else if (currentModule != null && mappingName.equals(currentModule.mappingName)) {
         // Extend the current module with this mapping (same file, continuation)
-        currentModule.extendTo(mapping.getEndAddress());
+        currentModule.extendTo(mapping.endAddress);
       }
     }
 
@@ -333,6 +349,8 @@ private DebugMeta createDebugMeta(@NonNull final TombstoneProtos.Tombstone tombs
 
   @Override
   public void close() throws IOException {
-    tombstoneStream.close();
+    if (tombstoneStream != null) {
+      tombstoneStream.close();
+    }
   }
 }
diff --git a/sentry-android-core/src/main/proto/io/sentry/android/core/internal/tombstone/tombstone.proto b/sentry-android-core/src/main/proto/io/sentry/android/core/internal/tombstone/tombstone.proto
deleted file mode 100644
index 2f9cbe52850..00000000000
--- a/sentry-android-core/src/main/proto/io/sentry/android/core/internal/tombstone/tombstone.proto
+++ /dev/null
@@ -1,218 +0,0 @@
-// Added and adapted from: https://android.googlesource.com/platform/system/core/+/refs/heads/main/debuggerd/proto/tombstone.proto
-// Sentry changes:
-// * change the java_package
-//
-// Copyright (C) 2020 The Android Open Source Project
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Protobuf definition for Android tombstones.
-//
-// An app can get hold of these for any `REASON_CRASH_NATIVE` instance of
-// `android.app.ApplicationExitInfo`.
-//
-// https://developer.android.com/reference/android/app/ApplicationExitInfo#getTraceInputStream()
-//
-syntax = "proto3";
-option java_package = "io.sentry.android.core.internal.tombstone";
-option java_outer_classname = "TombstoneProtos";
-// NOTE TO OEMS:
-// If you add custom fields to this proto, do not use numbers in the reserved range.
-// NOTE TO CONSUMERS:
-// With proto3 -- unlike proto2 -- HasValue is unreliable for any field
-// where the default value for that type is also a valid value for the field.
-// This means, for example, that a boolean that is false or an integer that
-// is zero will appear to be missing --- but because they're not actually
-// marked as `optional` in this schema, consumers should just use values
-// without first checking whether or not they're "present".
-// https://protobuf.dev/programming-guides/proto3/#default
-message CrashDetail {
-  bytes name = 1;
-  bytes data = 2;
-  reserved 3 to 999;
-}
-message StackHistoryBufferEntry {
-  BacktraceFrame addr = 1;
-  uint64 fp = 2;
-  uint64 tag = 3;
-  reserved 4 to 999;
-}
-message StackHistoryBuffer {
-  uint64 tid = 1;
-  repeated StackHistoryBufferEntry entries = 2;
-  reserved 3 to 999;
-}
-message Tombstone {
-  Architecture arch = 1;
-  Architecture guest_arch = 24;
-  string build_fingerprint = 2;
-  string revision = 3;
-  string timestamp = 4;
-  uint32 pid = 5;
-  uint32 tid = 6;
-  uint32 uid = 7;
-  string selinux_label = 8;
-  repeated string command_line = 9;
-  // Process uptime in seconds.
-  uint32 process_uptime = 20;
-  Signal signal_info = 10;
-  string abort_message = 14;
-  repeated CrashDetail crash_details = 21;
-  repeated Cause causes = 15;
-  map<uint32, Thread> threads = 16;
-  map<uint32, Thread> guest_threads = 25;
-  repeated MemoryMapping memory_mappings = 17;
-  repeated LogBuffer log_buffers = 18;
-  repeated FD open_fds = 19;
-  uint32 page_size = 22;
-  bool has_been_16kb_mode = 23;
-  StackHistoryBuffer stack_history_buffer = 26;
-  reserved 27 to 999;
-}
-enum Architecture {
-  ARM32 = 0;
-  ARM64 = 1;
-  X86 = 2;
-  X86_64 = 3;
-  RISCV64 = 4;
-  NONE = 5;
-  reserved 6 to 999;
-}
-message Signal {
-  int32 number = 1;
-  string name = 2;
-  int32 code = 3;
-  string code_name = 4;
-  bool has_sender = 5;
-  int32 sender_uid = 6;
-  int32 sender_pid = 7;
-  bool has_fault_address = 8;
-  uint64 fault_address = 9;
-  // Note, may or may not contain the dump of the actual memory contents. Currently, on arm64, we
-  // only include metadata, and not the contents.
-  MemoryDump fault_adjacent_metadata = 10;
-  reserved 11 to 999;
-}
-message HeapObject {
-  uint64 address = 1;
-  uint64 size = 2;
-  uint64 allocation_tid = 3;
-  repeated BacktraceFrame allocation_backtrace = 4;
-  uint64 deallocation_tid = 5;
-  repeated BacktraceFrame deallocation_backtrace = 6;
-}
-message MemoryError {
-  enum Tool {
-    GWP_ASAN = 0;
-    SCUDO = 1;
-    reserved 2 to 999;
-  }
-  Tool tool = 1;
-  enum Type {
-    UNKNOWN = 0;
-    USE_AFTER_FREE = 1;
-    DOUBLE_FREE = 2;
-    INVALID_FREE = 3;
-    BUFFER_OVERFLOW = 4;
-    BUFFER_UNDERFLOW = 5;
-    reserved 6 to 999;
-  }
-  Type type = 2;
-  oneof location {
-    HeapObject heap = 3;
-  }
-  reserved 4 to 999;
-}
-message Cause {
-  string human_readable = 1;
-  oneof details {
-    MemoryError memory_error = 2;
-  }
-  reserved 3 to 999;
-}
-message Register {
-  string name = 1;
-  uint64 u64 = 2;
-  reserved 3 to 999;
-}
-message Thread {
-  int32 id = 1;
-  string name = 2;
-  repeated Register registers = 3;
-  repeated string backtrace_note = 7;
-  repeated string unreadable_elf_files = 9;
-  repeated BacktraceFrame current_backtrace = 4;
-  repeated MemoryDump memory_dump = 5;
-  int64 tagged_addr_ctrl = 6;
-  int64 pac_enabled_keys = 8;
-  reserved 10 to 999;
-}
-message BacktraceFrame {
-  uint64 rel_pc = 1;
-  uint64 pc = 2;
-  uint64 sp = 3;
-  string function_name = 4;
-  uint64 function_offset = 5;
-  string file_name = 6;
-  uint64 file_map_offset = 7;
-  string build_id = 8;
-  reserved 9 to 999;
-}
-message ArmMTEMetadata {
-  // One memory tag per granule (e.g. every 16 bytes) of regular memory.
-  bytes memory_tags = 1;
-  reserved 2 to 999;
-}
-message MemoryDump {
-  string register_name = 1;
-  string mapping_name = 2;
-  uint64 begin_address = 3;
-  bytes memory = 4;
-  oneof metadata {
-    ArmMTEMetadata arm_mte_metadata = 6;
-  }
-  reserved 5, 7 to 999;
-}
-message MemoryMapping {
-  uint64 begin_address = 1;
-  uint64 end_address = 2;
-  uint64 offset = 3;
-  bool read = 4;
-  bool write = 5;
-  bool execute = 6;
-  string mapping_name = 7;
-  string build_id = 8;
-  uint64 load_bias = 9;
-  reserved 10 to 999;
-}
-message FD {
-  int32 fd = 1;
-  string path = 2;
-  string owner = 3;
-  uint64 tag = 4;
-  reserved 5 to 999;
-}
-message LogBuffer {
-  string name = 1;
-  repeated LogMessage logs = 2;
-  reserved 3 to 999;
-}
-message LogMessage {
-  string timestamp = 1;
-  uint32 pid = 2;
-  uint32 tid = 3;
-  uint32 priority = 4;
-  string tag = 5;
-  string message = 6;
-  reserved 7 to 999;
-}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt
index 516b9190022..34e704188c4 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt
@@ -1,9 +1,13 @@
 package io.sentry.android.core.internal.tombstone
 
+import com.abovevacant.epitaph.core.BacktraceFrame
+import com.abovevacant.epitaph.core.MemoryMapping
+import com.abovevacant.epitaph.core.Signal
+import com.abovevacant.epitaph.core.Tombstone
+import com.abovevacant.epitaph.core.TombstoneThread
 import io.sentry.ILogger
 import io.sentry.JsonObjectWriter
 import io.sentry.protocol.DebugMeta
-import java.io.ByteArrayInputStream
 import java.io.StringWriter
 import java.util.zip.GZIPInputStream
 import kotlin.test.Test
@@ -56,12 +60,15 @@ class TombstoneParserTest {
   val nativeLibraryDir =
     "/data/app/~~gu-2hA9_Zg6tfIuDAbLpKA==/io.sentry.samples.android-MFqmKAMnl9AjNlHcO3mejA==/lib/arm64"
 
+  val parser = TombstoneParser(inAppIncludes, inAppExcludes, nativeLibraryDir)
+
   @Test
   fun `parses a snapshot tombstone into Event`() {
     val tombstoneStream =
       GZIPInputStream(TombstoneParserTest::class.java.getResourceAsStream("/tombstone.pb.gz"))
-    val parser = TombstoneParser(tombstoneStream, inAppIncludes, inAppExcludes, nativeLibraryDir)
-    val event = parser.parse()
+    val streamParser =
+      TombstoneParser(tombstoneStream, inAppIncludes, inAppExcludes, nativeLibraryDir)
+    val event = streamParser.parse()
 
     // top-level data
     assertNotNull(event.eventId)
@@ -137,87 +144,82 @@ class TombstoneParserTest {
     val buildId = "f1c3bcc0279865fe3058404b2831d9e64135386c"
 
     val tombstone =
-      TombstoneProtos.Tombstone.newBuilder()
-        .setPid(1234)
-        .setTid(1234)
-        .setSignalInfo(
-          TombstoneProtos.Signal.newBuilder()
-            .setNumber(11)
-            .setName("SIGSEGV")
-            .setCode(1)
-            .setCodeName("SEGV_MAPERR")
-        )
+      Tombstone.Builder()
+        .pid(1234)
+        .tid(1234)
+        .signal(Signal(11, "SIGSEGV", 1, "SEGV_MAPERR", false, 0, 0, false, 0, null))
         // First mapping: r--p at offset 0 (ELF header, has build_id)
-        .addMemoryMappings(
-          TombstoneProtos.MemoryMapping.newBuilder()
-            .setBuildId(buildId)
-            .setMappingName("/system/lib64/libc.so")
-            .setBeginAddress(0x7000000000)
-            .setEndAddress(0x7000001000)
-            .setOffset(0)
-            .setRead(true)
-            .setWrite(false)
-            .setExecute(false)
+        .addMemoryMapping(
+          MemoryMapping(
+            0x7000000000,
+            0x7000001000,
+            0,
+            true,
+            false,
+            false,
+            "/system/lib64/libc.so",
+            buildId,
+            0,
+          )
         )
         // Second mapping: r-xp at offset 0x1000 (executable segment)
-        .addMemoryMappings(
-          TombstoneProtos.MemoryMapping.newBuilder()
-            .setBuildId(buildId)
-            .setMappingName("/system/lib64/libc.so")
-            .setBeginAddress(0x7000001000)
-            .setEndAddress(0x7000010000)
-            .setOffset(0x1000)
-            .setRead(true)
-            .setWrite(false)
-            .setExecute(true)
+        .addMemoryMapping(
+          MemoryMapping(
+            0x7000001000,
+            0x7000010000,
+            0x1000,
+            true,
+            false,
+            true,
+            "/system/lib64/libc.so",
+            buildId,
+            0,
+          )
         )
         // Third mapping: r--p at offset 0x10000 (read-only data)
-        .addMemoryMappings(
-          TombstoneProtos.MemoryMapping.newBuilder()
-            .setBuildId(buildId)
-            .setMappingName("/system/lib64/libc.so")
-            .setBeginAddress(0x7000010000)
-            .setEndAddress(0x7000011000)
-            .setOffset(0x10000)
-            .setRead(true)
-            .setWrite(false)
-            .setExecute(false)
+        .addMemoryMapping(
+          MemoryMapping(
+            0x7000010000,
+            0x7000011000,
+            0x10000,
+            true,
+            false,
+            false,
+            "/system/lib64/libc.so",
+            buildId,
+            0,
+          )
         )
         // Fourth mapping: rw-p at offset 0x11000 (writable data)
-        .addMemoryMappings(
-          TombstoneProtos.MemoryMapping.newBuilder()
-            .setBuildId(buildId)
-            .setMappingName("/system/lib64/libc.so")
-            .setBeginAddress(0x7000011000)
-            .setEndAddress(0x7000012000)
-            .setOffset(0x11000)
-            .setRead(true)
-            .setWrite(true)
-            .setExecute(false)
+        .addMemoryMapping(
+          MemoryMapping(
+            0x7000011000,
+            0x7000012000,
+            0x11000,
+            true,
+            true,
+            false,
+            "/system/lib64/libc.so",
+            buildId,
+            0,
+          )
         )
-        .putThreads(
-          1234,
-          TombstoneProtos.Thread.newBuilder()
-            .setId(1234)
-            .setName("main")
-            .addCurrentBacktrace(
-              TombstoneProtos.BacktraceFrame.newBuilder()
-                .setPc(0x7000001100)
-                .setFunctionName("crash")
-                .setFileName("/system/lib64/libc.so")
-            )
-            .build(),
+        .addThread(
+          TombstoneThread(
+            1234,
+            "main",
+            emptyList(),
+            emptyList(),
+            emptyList(),
+            listOf(BacktraceFrame(0, 0x7000001100, 0, "crash", 0, "/system/lib64/libc.so", 0, "")),
+            emptyList(),
+            0,
+            0,
+          )
         )
         .build()
 
-    val parser =
-      TombstoneParser(
-        ByteArrayInputStream(tombstone.toByteArray()),
-        inAppIncludes,
-        inAppExcludes,
-        nativeLibraryDir,
-      )
-    val event = parser.parse()
+    val event = parser.parse(tombstone)
 
     // All 4 mappings should be coalesced into a single module
     val images = event.debugMeta!!.images!!
@@ -238,77 +240,69 @@ class TombstoneParserTest {
     val buildId = "f1c3bcc0279865fe3058404b2831d9e64135386c"
 
     val tombstone =
-      TombstoneProtos.Tombstone.newBuilder()
-        .setPid(1234)
-        .setTid(1234)
-        .setSignalInfo(
-          TombstoneProtos.Signal.newBuilder()
-            .setNumber(11)
-            .setName("SIGSEGV")
-            .setCode(1)
-            .setCodeName("SEGV_MAPERR")
-        )
+      Tombstone.Builder()
+        .pid(1234)
+        .tid(1234)
+        .signal(Signal(11, "SIGSEGV", 1, "SEGV_MAPERR", false, 0, 0, false, 0, null))
         // First mapping: r--p at offset 0
-        .addMemoryMappings(
-          TombstoneProtos.MemoryMapping.newBuilder()
-            .setBuildId(buildId)
-            .setMappingName("/system/lib64/libdl.so")
-            .setBeginAddress(0x7000000000)
-            .setEndAddress(0x7000001000)
-            .setOffset(0)
-            .setRead(true)
-            .setWrite(false)
-            .setExecute(false)
+        .addMemoryMapping(
+          MemoryMapping(
+            0x7000000000,
+            0x7000001000,
+            0,
+            true,
+            false,
+            false,
+            "/system/lib64/libdl.so",
+            buildId,
+            0,
+          )
         )
         // Second mapping: r-xp at offset 0 (duplicate!)
-        .addMemoryMappings(
-          TombstoneProtos.MemoryMapping.newBuilder()
-            .setBuildId(buildId)
-            .setMappingName("/system/lib64/libdl.so")
-            .setBeginAddress(0x7000001000)
-            .setEndAddress(0x7000002000)
-            .setOffset(0)
-            .setRead(true)
-            .setWrite(false)
-            .setExecute(true)
+        .addMemoryMapping(
+          MemoryMapping(
+            0x7000001000,
+            0x7000002000,
+            0,
+            true,
+            false,
+            true,
+            "/system/lib64/libdl.so",
+            buildId,
+            0,
+          )
         )
         // Third mapping: r--p at offset 0 (another duplicate!)
-        .addMemoryMappings(
-          TombstoneProtos.MemoryMapping.newBuilder()
-            .setBuildId(buildId)
-            .setMappingName("/system/lib64/libdl.so")
-            .setBeginAddress(0x7000002000)
-            .setEndAddress(0x7000003000)
-            .setOffset(0)
-            .setRead(true)
-            .setWrite(false)
-            .setExecute(false)
+        .addMemoryMapping(
+          MemoryMapping(
+            0x7000002000,
+            0x7000003000,
+            0,
+            true,
+            false,
+            false,
+            "/system/lib64/libdl.so",
+            buildId,
+            0,
+          )
         )
-        .putThreads(
-          1234,
-          TombstoneProtos.Thread.newBuilder()
-            .setId(1234)
-            .setName("main")
-            .addCurrentBacktrace(
-              TombstoneProtos.BacktraceFrame.newBuilder()
-                .setPc(0x7000001100)
-                .setFunctionName("crash")
-                .setFileName("/system/lib64/libdl.so")
-            )
-            .build(),
+        .addThread(
+          TombstoneThread(
+            1234,
+            "main",
+            emptyList(),
+            emptyList(),
+            emptyList(),
+            listOf(BacktraceFrame(0, 0x7000001100, 0, "crash", 0, "/system/lib64/libdl.so", 0, "")),
+            emptyList(),
+            0,
+            0,
+          )
         )
         .build()
 
-    val parser =
-      TombstoneParser(
-        ByteArrayInputStream(tombstone.toByteArray()),
-        inAppIncludes,
-        inAppExcludes,
-        nativeLibraryDir,
-      )
-    val event = parser.parse()
+    val event = parser.parse(tombstone)
 
-    // All duplicate mappings should be coalesced into a single module
     val images = event.debugMeta!!.images!!
     assertEquals(1, images.size)
 
@@ -327,59 +321,52 @@ class TombstoneParserTest {
     val validBuildId = "f1c3bcc0279865fe3058404b2831d9e64135386c"
 
     val tombstone =
-      TombstoneProtos.Tombstone.newBuilder()
-        .setPid(1234)
-        .setTid(1234)
-        .setSignalInfo(
-          TombstoneProtos.Signal.newBuilder()
-            .setNumber(11)
-            .setName("SIGSEGV")
-            .setCode(1)
-            .setCodeName("SEGV_MAPERR")
-        )
-        .addMemoryMappings(
-          TombstoneProtos.MemoryMapping.newBuilder()
-            .setBuildId(invalidBuildId)
-            .setMappingName("/system/lib64/libc.so")
-            .setBeginAddress(0x7000000000)
-            .setEndAddress(0x7000001000)
-            .setOffset(0)
-            .setRead(true)
-            .setExecute(true)
+      Tombstone.Builder()
+        .pid(1234)
+        .tid(1234)
+        .signal(Signal(11, "SIGSEGV", 1, "SEGV_MAPERR", false, 0, 0, false, 0, null))
+        .addMemoryMapping(
+          MemoryMapping(
+            0x7000000000,
+            0x7000001000,
+            0,
+            true,
+            false,
+            true,
+            "/system/lib64/libc.so",
+            invalidBuildId,
+            0,
+          )
         )
-        .addMemoryMappings(
-          TombstoneProtos.MemoryMapping.newBuilder()
-            .setBuildId(validBuildId)
-            .setMappingName("/system/lib64/libm.so")
-            .setBeginAddress(0x7000002000)
-            .setEndAddress(0x7000003000)
-            .setOffset(0)
-            .setRead(true)
-            .setExecute(true)
+        .addMemoryMapping(
+          MemoryMapping(
+            0x7000002000,
+            0x7000003000,
+            0,
+            true,
+            false,
+            true,
+            "/system/lib64/libm.so",
+            validBuildId,
+            0,
+          )
         )
-        .putThreads(
-          1234,
-          TombstoneProtos.Thread.newBuilder()
-            .setId(1234)
-            .setName("main")
-            .addCurrentBacktrace(
-              TombstoneProtos.BacktraceFrame.newBuilder()
-                .setPc(0x7000000100)
-                .setFunctionName("crash")
-                .setFileName("/system/lib64/libc.so")
-            )
-            .build(),
+        .addThread(
+          TombstoneThread(
+            1234,
+            "main",
+            emptyList(),
+            emptyList(),
+            emptyList(),
+            listOf(BacktraceFrame(0, 0x7000000100, 0, "crash", 0, "/system/lib64/libc.so", 0, "")),
+            emptyList(),
+            0,
+            0,
+          )
         )
         .build()
 
-    val parser =
-      TombstoneParser(
-        ByteArrayInputStream(tombstone.toByteArray()),
-        inAppIncludes,
-        inAppExcludes,
-        nativeLibraryDir,
-      )
-    val event = parser.parse()
+    val event = parser.parse(tombstone)
 
     val images = event.debugMeta!!.images!!
     assertEquals(2, images.size)
@@ -400,8 +387,9 @@ class TombstoneParserTest {
     // test against a full snapshot so that we can track regressions in the VMA -> module reduction
     val tombstoneStream =
       GZIPInputStream(TombstoneParserTest::class.java.getResourceAsStream("/tombstone.pb.gz"))
-    val parser = TombstoneParser(tombstoneStream, inAppIncludes, inAppExcludes, nativeLibraryDir)
-    val event = parser.parse()
+    val streamParser =
+      TombstoneParser(tombstoneStream, inAppIncludes, inAppExcludes, nativeLibraryDir)
+    val event = streamParser.parse()
 
     val actualJson = serializeDebugMeta(event.debugMeta!!)
     val expectedJson = readGzippedResourceFile("/tombstone_debug_meta.json.gz")

From 6a6b6c63c43109d3abcd1b0b2a7f2228eee0a4ec Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Mon, 9 Mar 2026 14:46:25 +0100
Subject: [PATCH 042/391] docs: Add collection branch safety warnings to PR
 workflow (#5176)

Add explicit warnings to pr.mdc and create-java-pr skill that the
collection branch must never be manually merged or fast-forwarded.
Updating it causes GitHub to auto-merge all stack PRs and delete
their branches, destroying the entire stack.

Co-authored-by: Claude <noreply@anthropic.com>
---
 .claude/skills/create-java-pr/SKILL.md | 2 ++
 .cursor/rules/pr.mdc                   | 8 ++++++--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/.claude/skills/create-java-pr/SKILL.md b/.claude/skills/create-java-pr/SKILL.md
index b0fc12a5d2e..9a0bf71eec8 100644
--- a/.claude/skills/create-java-pr/SKILL.md
+++ b/.claude/skills/create-java-pr/SKILL.md
@@ -35,6 +35,8 @@ Derive the branch name from the changes being made. Use `feat/`, `fix/`, `ref/`,
 
 **For stacked PRs:** For the first PR in a new stack, first create and push the collection branch (see `.cursor/rules/pr.mdc` § "Creating the Collection Branch"), then branch the PR off it. For subsequent PRs, branch off the previous stack branch. Use the naming conventions from `.cursor/rules/pr.mdc` § "Branch Naming".
 
+**CRITICAL: Never merge, fast-forward, or push commits into the collection branch.** It stays at its initial position until the user merges stack PRs through GitHub. Updating it will auto-merge and destroy the entire PR stack.
+
 ## Step 2: Format Code and Regenerate API Files
 
 ```bash
diff --git a/.cursor/rules/pr.mdc b/.cursor/rules/pr.mdc
index 3b8f73194b1..d1926a640fe 100644
--- a/.cursor/rules/pr.mdc
+++ b/.cursor/rules/pr.mdc
@@ -185,6 +185,8 @@ git push -u origin HEAD
 gh pr create --base main --draft --title "<type>(<scope>): <Topic>" --body "Collection PR for the <Topic> stack. Squash-merge this once all stack PRs are merged."
 ```
 
+**CRITICAL: Do NOT manually update the collection branch.** Never merge, fast-forward, or push stack branch commits into the collection branch. The collection branch stays at its initial position (the empty commit on `main`) until the user merges individual stack PRs into it one by one through GitHub. If you fast-forward the collection branch to include stack commits, GitHub will auto-merge and delete all stack PR branches, destroying the entire stack.
+
 ### Creating a New Stacked PR
 
 1. Start from the tip of the previous stack branch (or the collection branch for the first PR).
@@ -237,12 +239,12 @@ Once all stack PRs are merged into the collection branch, the collection PR is *
 
 ### Syncing the Stack
 
-When a base PR changes (e.g. after addressing review feedback on PR 1), merge the changes forward through the stack:
+When a base PR changes (e.g. after addressing review feedback on PR 1), merge the changes forward through the stack **between adjacent stack PR branches only**:
 
 ```bash
 # On the branch for PR 2
 git checkout feat/scope-attributes-logger
-git merge feat/scope-attributes
+git merge feat/scope-attributes-api
 git push
 
 # On the branch for PR 3
@@ -251,4 +253,6 @@ git merge feat/scope-attributes-logger
 git push
 ```
 
+**Never merge into the collection branch.** Syncing only happens between stack PR branches. The collection branch is untouched until the user merges PRs through GitHub.
+
 Prefer merge over rebase — it preserves commit history, doesn't invalidate existing review comments, and avoids the need for force-pushing. Only rebase if explicitly requested.

From b1045ed46a79eb58f9d2cd96d57dcaa150b4346b Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Mon, 9 Mar 2026 15:29:36 +0100
Subject: [PATCH 043/391] docs: Improve stacked PR workflow for collection
 branch and merge method (#5178)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* docs: Add collection branch safety warnings to PR workflow

Add explicit warnings to pr.mdc and create-java-pr skill that the
collection branch must never be manually merged or fast-forwarded.
Updating it causes GitHub to auto-merge all stack PRs and delete
their branches, destroying the entire stack.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs: Include collection branch PR in stack list updates

The stack list update instructions only mentioned "all PRs in the
stack" which was ambiguous — it could be read as excluding the
collection branch PR. Now both pr.mdc and the create-java-pr skill
explicitly call out that the collection branch PR must also be updated
with the stack list.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs: Add merge commit reminder to stack PR descriptions

Stack PRs must be merged with merge commits, not squash. Add a
reminder to the PR description so reviewers/mergers pick the right
method. This only applies to stack PRs — not standalone PRs or the
collection branch PR.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .claude/skills/create-java-pr/SKILL.md |  3 ++-
 .cursor/rules/pr.mdc                   | 10 +++++++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/.claude/skills/create-java-pr/SKILL.md b/.claude/skills/create-java-pr/SKILL.md
index 9a0bf71eec8..cb2618e6477 100644
--- a/.claude/skills/create-java-pr/SKILL.md
+++ b/.claude/skills/create-java-pr/SKILL.md
@@ -113,6 +113,7 @@ Fill in each section based on the changes being PR'd. Check any checklist items
 - Pass `--base <previous-stack-branch>` so the PR targets the previous branch (first PR in a stack targets the collection branch).
 - Use the stacked PR title format: `<type>(<scope>): [<Topic> <N>] <Subject>` (see `.cursor/rules/pr.mdc` § "PR Title Naming").
 - Include the stack list at the top of the PR body, before the `## :scroll: Description` section (see `.cursor/rules/pr.mdc` § "Stack List in PR Description" for the format).
+- Add a merge method reminder at the very end of the PR body (see `.cursor/rules/pr.mdc` § "Stack List in PR Description" for the exact text). This only applies to stack PRs, not the collection branch PR.
 
 Then continue to Step 5.5 (stacked PRs only) or Step 6.
 
@@ -120,7 +121,7 @@ Then continue to Step 5.5 (stacked PRs only) or Step 6.
 
 Skip this step for standalone PRs.
 
-After creating the PR, update the PR description on **every other PR in the stack** so all PRs have the same up-to-date stack list. Follow the format and commands in `.cursor/rules/pr.mdc` § "Stack List in PR Description".
+After creating the PR, update the PR description on **every other PR in the stack — including the collection branch PR** — so all PRs have the same up-to-date stack list. Follow the format and commands in `.cursor/rules/pr.mdc` § "Stack List in PR Description".
 
 ## Step 6: Update Changelog
 
diff --git a/.cursor/rules/pr.mdc b/.cursor/rules/pr.mdc
index d1926a640fe..df35ee3b944 100644
--- a/.cursor/rules/pr.mdc
+++ b/.cursor/rules/pr.mdc
@@ -199,7 +199,7 @@ gh pr create --base main --draft --title "<type>(<scope>): <Topic>" --body "Coll
 
 ### Stack List in PR Description
 
-Every PR in the stack must have a stack list **at the top of its description** (before the `## :scroll: Description` section). When a new PR is added, update the description on **all** PRs in the stack.
+Every PR in the stack — **including the collection branch PR** — must have a stack list **at the top of its description** (before the `## :scroll: Description` section). When a new PR is added, update the description on **all** PRs in the stack and on the collection branch PR.
 
 Format:
 
@@ -215,6 +215,14 @@ Format:
 
 No status column — GitHub already shows that. The `---` separates the stack list from the rest of the PR description.
 
+**Merge method reminder:** On stack PRs (not the collection branch PR), add the following line at the very end of the PR description:
+
+```markdown
+> ⚠️ **Merge this PR using a merge commit** (not squash). Only the collection branch is squash-merged into main.
+```
+
+This does not apply to standalone PRs or the collection branch PR.
+
 To update the PR description, use `--body-file` to avoid shell quoting issues with special characters in the body:
 
 ```bash

From ee611d9dc13449cb863122c3a9d49b40e01a99d9 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 10 Mar 2026 11:22:16 +0100
Subject: [PATCH 044/391] feat(samples): [Global Attributes 6] Showcase scope
 attributes in all sample modules (#5149)

* feat(core): Add scope-level attributes API

Add setAttribute, setAttributes, removeAttribute, and getAttributes
to IScope/IScopes/Sentry so users can set attributes on the scope
that are automatically included in logs and metrics events.

Also refactor type inference logic into SentryAttributeType.inferFrom
and add SentryLogEventAttributeValue.fromAttribute factory method,
removing duplicate getType helpers from LoggerApi and MetricsApi.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* ref: Split out LoggerApi/MetricsApi changes for stacked PR

Move factory method extractions (SentryAttributeType.inferFrom,
SentryLogEventAttributeValue.fromAttribute) and LoggerApi/MetricsApi
scope attribute integration to a separate stacked PR.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(core): Wire scope attributes into LoggerApi and MetricsApi

Extract factory methods SentryAttributeType.inferFrom and
SentryLogEventAttributeValue.fromAttribute to reduce duplication.
Apply scope attributes to log and metric events automatically.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* feat(samples): Showcase scope attributes in Spring Boot 4 samples

Add Sentry.setAttribute() calls to PersonController and
MetricController across all Spring Boot 4 sample variants to
demonstrate scope attributes being auto-attached to logs and metrics.

Add e2e test assertions and TestHelper methods to verify scope
attributes appear on captured log and metric events.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* Revert "changelog"

This reverts commit 7189bdca1a211085608f16bf3443c9e6675b6680.

* ref: Remove redundant comments from variant controllers

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref: Limit scope attributes sample to base Spring Boot 4 variant

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: Detect integer attribute type correctly for all integer Number subtypes

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* feat: Support collections and arrays in log attribute type inference

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* test: Add coverage for arrayAttribute factory method

Add arrayAttribute and named array attribute usage to the four
attribute tests in ScopesTest (log, count metric, distribution metric,
gauge metric) to verify the factory method works end-to-end.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(samples): Showcase scope attributes in all sample modules

Add Sentry.setAttribute() calls to all sample source files and
corresponding attribute assertions to all system tests. This extends
the scope attributes showcase from sentry-samples-spring-boot-4 to
all 19 remaining sample modules with system tests.

Co-Authored-By: Claude <noreply@anthropic.com>

* Format code

* ci: trigger CI re-run

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ci: retrigger CI

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* remove duplicate changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 .../main/java/io/sentry/samples/console/Main.java |  2 ++
 .../systemtest/ConsoleApplicationSystemTest.kt    |  4 +++-
 .../main/java/io/sentry/samples/console/Main.java |  2 ++
 .../systemtest/ConsoleApplicationSystemTest.kt    |  4 +++-
 .../src/main/java/io/sentry/samples/jul/Main.java |  3 +++
 .../systemtest/ConsoleApplicationSystemTest.kt    | 15 ++++++++++++++-
 .../main/java/io/sentry/samples/log4j2/Main.java  |  3 +++
 .../systemtest/ConsoleApplicationSystemTest.kt    | 15 ++++++++++++++-
 .../main/java/io/sentry/samples/logback/Main.java |  3 +++
 .../systemtest/ConsoleApplicationSystemTest.kt    | 15 ++++++++++++++-
 .../samples/spring7/web/MetricController.java     |  2 ++
 .../samples/spring7/web/PersonController.java     |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../samples/spring/boot4/MetricController.java    |  2 ++
 .../samples/spring/boot4/PersonController.java    |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../samples/spring/boot4/MetricController.java    |  2 ++
 .../samples/spring/boot4/PersonController.java    |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../samples/spring/boot4/MetricController.java    |  2 ++
 .../samples/spring/boot4/PersonController.java    |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../spring/boot/jakarta/MetricController.java     |  2 ++
 .../spring/boot/jakarta/PersonController.java     |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../spring/boot/jakarta/MetricController.java     |  2 ++
 .../spring/boot/jakarta/PersonController.java     |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../spring/boot/jakarta/MetricController.java     |  2 ++
 .../spring/boot/jakarta/PersonController.java     |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../samples/spring/boot/MetricController.java     |  2 ++
 .../samples/spring/boot/PersonController.java     |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../samples/spring/boot/MetricController.java     |  2 ++
 .../samples/spring/boot/PersonController.java     |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../spring/boot/jakarta/MetricController.java     |  2 ++
 .../spring/boot/jakarta/PersonController.java     |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../samples/spring/boot/MetricController.java     |  2 ++
 .../samples/spring/boot/PersonController.java     |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../samples/spring/boot/MetricController.java     |  2 ++
 .../samples/spring/boot/PersonController.java     |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../spring/jakarta/web/MetricController.java      |  2 ++
 .../spring/jakarta/web/PersonController.java      |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 .../samples/spring/web/MetricController.java      |  2 ++
 .../samples/spring/web/PersonController.java      |  3 +++
 .../io/sentry/systemtest/MetricsSystemTest.kt     |  4 +++-
 .../io/sentry/systemtest/PersonSystemTest.kt      | 15 ++++++++++++++-
 66 files changed, 369 insertions(+), 33 deletions(-)

diff --git a/sentry-samples/sentry-samples-console-opentelemetry-noagent/src/main/java/io/sentry/samples/console/Main.java b/sentry-samples/sentry-samples-console-opentelemetry-noagent/src/main/java/io/sentry/samples/console/Main.java
index 9efab21031d..21438ee496c 100644
--- a/sentry-samples/sentry-samples-console-opentelemetry-noagent/src/main/java/io/sentry/samples/console/Main.java
+++ b/sentry-samples/sentry-samples-console-opentelemetry-noagent/src/main/java/io/sentry/samples/console/Main.java
@@ -63,6 +63,8 @@ public static void main(String[] args) throws InterruptedException {
 
     Sentry.addFeatureFlag("my-feature-flag", true);
 
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     captureMetrics();
 
     // Sending exception:
diff --git a/sentry-samples/sentry-samples-console-opentelemetry-noagent/src/test/kotlin/sentry/systemtest/ConsoleApplicationSystemTest.kt b/sentry-samples/sentry-samples-console-opentelemetry-noagent/src/test/kotlin/sentry/systemtest/ConsoleApplicationSystemTest.kt
index 7a89e5b1e6f..4f21ebefd70 100644
--- a/sentry-samples/sentry-samples-console-opentelemetry-noagent/src/test/kotlin/sentry/systemtest/ConsoleApplicationSystemTest.kt
+++ b/sentry-samples/sentry-samples-console-opentelemetry-noagent/src/test/kotlin/sentry/systemtest/ConsoleApplicationSystemTest.kt
@@ -111,7 +111,9 @@ class ConsoleApplicationSystemTest {
     testHelper.ensureMetricsReceived { metricsEvents, sentryEnvelopeHeader ->
       testHelper.doesContainMetric(metricsEvents, "countMetric", "counter", 1.0) &&
         testHelper.doesContainMetric(metricsEvents, "gaugeMetric", "gauge", 5.0) &&
-        testHelper.doesContainMetric(metricsEvents, "distributionMetric", "distribution", 7.0)
+        testHelper.doesContainMetric(metricsEvents, "distributionMetric", "distribution", 7.0) &&
+        testHelper.doesMetricHaveAttribute(metricsEvents, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(metricsEvents, "countMetric", "feature.version", 2)
     }
   }
 }
diff --git a/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java b/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java
index fd21476f402..29fae9381b2 100644
--- a/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java
+++ b/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java
@@ -128,6 +128,8 @@ public static void main(String[] args) throws InterruptedException {
 
     Sentry.addFeatureFlag("my-feature-flag", true);
 
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     captureMetrics();
 
     // Sending exception:
diff --git a/sentry-samples/sentry-samples-console/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt b/sentry-samples/sentry-samples-console/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
index 9f968485345..2b009167acb 100644
--- a/sentry-samples/sentry-samples-console/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
+++ b/sentry-samples/sentry-samples-console/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
@@ -106,7 +106,9 @@ class ConsoleApplicationSystemTest {
     testHelper.ensureMetricsReceived { metricsEvents, sentryEnvelopeHeader ->
       testHelper.doesContainMetric(metricsEvents, "countMetric", "counter", 1.0) &&
         testHelper.doesContainMetric(metricsEvents, "gaugeMetric", "gauge", 5.0) &&
-        testHelper.doesContainMetric(metricsEvents, "distributionMetric", "distribution", 7.0)
+        testHelper.doesContainMetric(metricsEvents, "distributionMetric", "distribution", 7.0) &&
+        testHelper.doesMetricHaveAttribute(metricsEvents, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(metricsEvents, "countMetric", "feature.version", 2)
     }
   }
 }
diff --git a/sentry-samples/sentry-samples-jul/src/main/java/io/sentry/samples/jul/Main.java b/sentry-samples/sentry-samples-jul/src/main/java/io/sentry/samples/jul/Main.java
index 9f245470af4..16e7542988a 100644
--- a/sentry-samples/sentry-samples-jul/src/main/java/io/sentry/samples/jul/Main.java
+++ b/sentry-samples/sentry-samples-jul/src/main/java/io/sentry/samples/jul/Main.java
@@ -23,6 +23,9 @@ public static void main(String[] args) throws Exception {
     MDC.put("userId", UUID.randomUUID().toString());
     MDC.put("requestId", UUID.randomUUID().toString());
 
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.addFeatureFlag("my-feature-flag", true);
 
     LOGGER.warning("important warning");
diff --git a/sentry-samples/sentry-samples-jul/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt b/sentry-samples/sentry-samples-jul/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
index d23428da943..9750dcd728f 100644
--- a/sentry-samples/sentry-samples-jul/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
+++ b/sentry-samples/sentry-samples-jul/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
@@ -64,7 +64,20 @@ class ConsoleApplicationSystemTest {
 
     testHelper.ensureLogsReceived { logs, _ ->
       testHelper.doesContainLogWithBody(logs, "User has made a purchase of product: 445") &&
-        testHelper.doesContainLogWithBody(logs, "Something went wrong")
+        testHelper.doesContainLogWithBody(logs, "Something went wrong") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "Something went wrong",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "Something went wrong",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "Something went wrong", "debug.enabled", true)
     }
   }
 }
diff --git a/sentry-samples/sentry-samples-log4j2/src/main/java/io/sentry/samples/log4j2/Main.java b/sentry-samples/sentry-samples-log4j2/src/main/java/io/sentry/samples/log4j2/Main.java
index 5703fff5d44..9d9d56fe72d 100644
--- a/sentry-samples/sentry-samples-log4j2/src/main/java/io/sentry/samples/log4j2/Main.java
+++ b/sentry-samples/sentry-samples-log4j2/src/main/java/io/sentry/samples/log4j2/Main.java
@@ -20,6 +20,9 @@ public static void main(String[] args) {
     // ThreadContext tag not listed in log4j2.xml
     ThreadContext.put("context-tag", "context-tag-value");
 
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.addFeatureFlag("my-feature-flag", true);
 
     // logging arguments are converted to Sentry Event parameters
diff --git a/sentry-samples/sentry-samples-log4j2/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt b/sentry-samples/sentry-samples-log4j2/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
index 5d3266c6ff8..e22488c2f36 100644
--- a/sentry-samples/sentry-samples-log4j2/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
+++ b/sentry-samples/sentry-samples-log4j2/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
@@ -66,7 +66,20 @@ class ConsoleApplicationSystemTest {
 
     testHelper.ensureLogsReceived { logs, _ ->
       testHelper.doesContainLogWithBody(logs, "User has made a purchase of product: 445") &&
-        testHelper.doesContainLogWithBody(logs, "Something went wrong")
+        testHelper.doesContainLogWithBody(logs, "Something went wrong") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "Something went wrong",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "Something went wrong",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "Something went wrong", "debug.enabled", true)
     }
   }
 }
diff --git a/sentry-samples/sentry-samples-logback/src/main/java/io/sentry/samples/logback/Main.java b/sentry-samples/sentry-samples-logback/src/main/java/io/sentry/samples/logback/Main.java
index ec3928998a4..cb6dbc52ce4 100644
--- a/sentry-samples/sentry-samples-logback/src/main/java/io/sentry/samples/logback/Main.java
+++ b/sentry-samples/sentry-samples-logback/src/main/java/io/sentry/samples/logback/Main.java
@@ -18,6 +18,9 @@ public static void main(String[] args) {
     // MDC tag not listed in logback.xml
     MDC.put("context-tag", "context-tag-value");
 
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.addFeatureFlag("my-feature-flag", true);
     LOGGER.warn("important warning");
 
diff --git a/sentry-samples/sentry-samples-logback/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt b/sentry-samples/sentry-samples-logback/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
index 40169882224..ad28ff77762 100644
--- a/sentry-samples/sentry-samples-logback/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
+++ b/sentry-samples/sentry-samples-logback/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
@@ -66,7 +66,20 @@ class ConsoleApplicationSystemTest {
 
     testHelper.ensureLogsReceived { logs, _ ->
       testHelper.doesContainLogWithBody(logs, "User has made a purchase of product: 445") &&
-        testHelper.doesContainLogWithBody(logs, "Something went wrong")
+        testHelper.doesContainLogWithBody(logs, "Something went wrong") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "Something went wrong",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "Something went wrong",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "Something went wrong", "debug.enabled", true)
     }
   }
 }
diff --git a/sentry-samples/sentry-samples-spring-7/src/main/java/io/sentry/samples/spring7/web/MetricController.java b/sentry-samples/sentry-samples-spring-7/src/main/java/io/sentry/samples/spring7/web/MetricController.java
index b7f7d566b9c..73fba080a12 100644
--- a/sentry-samples/sentry-samples-spring-7/src/main/java/io/sentry/samples/spring7/web/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-7/src/main/java/io/sentry/samples/spring7/web/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-7/src/main/java/io/sentry/samples/spring7/web/PersonController.java b/sentry-samples/sentry-samples-spring-7/src/main/java/io/sentry/samples/spring7/web/PersonController.java
index d66cf747c1f..3da15b55d4b 100644
--- a/sentry-samples/sentry-samples-spring-7/src/main/java/io/sentry/samples/spring7/web/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-7/src/main/java/io/sentry/samples/spring7/web/PersonController.java
@@ -23,6 +23,9 @@ public PersonController(PersonService personService) {
 
   @GetMapping("{id}")
   Person person(@PathVariable("id") Long id) {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.logger().warn("warn Sentry logging");
     Sentry.logger().error("error Sentry logging");
     Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-7/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-7/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index 3d7afa4f73a..0091de63008 100644
--- a/sentry-samples/sentry-samples-spring-7/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-7/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-7/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-7/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index 99968ef8f51..f0d6bd177e8 100644
--- a/sentry-samples/sentry-samples-spring-7/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-7/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -35,7 +35,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/MetricController.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
index 2a969ec8849..be75f5e3002 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/PersonController.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
index b96c840aae8..a38a0b8bb43 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
@@ -34,6 +34,9 @@ Person person(@PathVariable Long id) {
     Sentry.addFeatureFlag("outer-feature-flag", true);
     Span span = tracer.spanBuilder("spanCreatedThroughOtelApi").startSpan();
     try (final @NotNull Scope spanScope = span.makeCurrent()) {
+      Sentry.setAttribute("user.type", "admin");
+      Sentry.setAttribute("feature.version", 2);
+      Sentry.setAttribute("debug.enabled", true);
       Sentry.logger().warn("warn Sentry logging");
       Sentry.logger().error("error Sentry logging");
       Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index 50bc732b657..1fe742b64ce 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -56,7 +56,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/MetricController.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
index 2a969ec8849..be75f5e3002 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/PersonController.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
index bde91c83825..22259d4375c 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
@@ -32,6 +32,9 @@ Person person(@PathVariable Long id) {
     Sentry.addFeatureFlag("transaction-feature-flag", true);
     Span span = tracer.spanBuilder("spanCreatedThroughOtelApi").startSpan();
     try (final @NotNull Scope spanScope = span.makeCurrent()) {
+      Sentry.setAttribute("user.type", "admin");
+      Sentry.setAttribute("feature.version", 2);
+      Sentry.setAttribute("debug.enabled", true);
       Sentry.logger().warn("warn Sentry logging");
       Sentry.logger().error("error Sentry logging");
       Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index a4d7cc5bdc5..ad9b5f77b62 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -51,7 +51,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/MetricController.java b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
index 2a969ec8849..be75f5e3002 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/PersonController.java b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
index 0db43f5ab71..5ea8b2ea0bc 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/PersonController.java
@@ -23,6 +23,9 @@ public PersonController(PersonService personService) {
 
   @GetMapping("{id}")
   Person person(@PathVariable Long id) {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.logger().warn("warn Sentry logging");
     Sentry.logger().error("error Sentry logging");
     Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index 7ba241200d4..3b7b2751ee9 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -35,7 +35,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
index f7c7529525f..6b28e59d6a3 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
index 06e4bb963b0..cc8522e2ff1 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
@@ -34,6 +34,9 @@ Person person(@PathVariable Long id) {
     Sentry.addFeatureFlag("outer-feature-flag", true);
     Span span = tracer.spanBuilder("spanCreatedThroughOtelApi").startSpan();
     try (final @NotNull Scope spanScope = span.makeCurrent()) {
+      Sentry.setAttribute("user.type", "admin");
+      Sentry.setAttribute("feature.version", 2);
+      Sentry.setAttribute("debug.enabled", true);
       Sentry.logger().warn("warn Sentry logging");
       Sentry.logger().error("error Sentry logging");
       Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index 50bc732b657..1fe742b64ce 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -56,7 +56,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
index f7c7529525f..6b28e59d6a3 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
index b17809eb68d..74b38660f66 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
@@ -32,6 +32,9 @@ Person person(@PathVariable Long id) {
     Sentry.addFeatureFlag("transaction-feature-flag", true);
     Span span = tracer.spanBuilder("spanCreatedThroughOtelApi").startSpan();
     try (final @NotNull Scope spanScope = span.makeCurrent()) {
+      Sentry.setAttribute("user.type", "admin");
+      Sentry.setAttribute("feature.version", 2);
+      Sentry.setAttribute("debug.enabled", true);
       Sentry.logger().warn("warn Sentry logging");
       Sentry.logger().error("error Sentry logging");
       Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index a4d7cc5bdc5..ad9b5f77b62 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -51,7 +51,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
index f7c7529525f..6b28e59d6a3 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
index 2b590e1188b..f3c42b26081 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
@@ -27,6 +27,9 @@ Person person(@PathVariable Long id) {
     ISpan currentSpan = Sentry.getSpan();
     ISpan sentrySpan = currentSpan.startChild("spanCreatedThroughSentryApi");
     try {
+      Sentry.setAttribute("user.type", "admin");
+      Sentry.setAttribute("feature.version", 2);
+      Sentry.setAttribute("debug.enabled", true);
       Sentry.logger().warn("warn Sentry logging");
       Sentry.logger().error("error Sentry logging");
       Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index 362a8577148..2389734a8b3 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -50,7 +50,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/MetricController.java b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/MetricController.java
index da5b1d655de..352571ee434 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/PersonController.java b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/PersonController.java
index 2f7aa4e03c8..c7d3d360e1a 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/PersonController.java
@@ -34,6 +34,9 @@ Person person(@PathVariable Long id) {
     Sentry.addFeatureFlag("outer-feature-flag", true);
     Span span = tracer.spanBuilder("spanCreatedThroughOtelApi").startSpan();
     try (final @NotNull Scope spanScope = span.makeCurrent()) {
+      Sentry.setAttribute("user.type", "admin");
+      Sentry.setAttribute("feature.version", 2);
+      Sentry.setAttribute("debug.enabled", true);
       Sentry.logger().warn("warn Sentry logging");
       Sentry.logger().error("error Sentry logging");
       Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index 50bc732b657..1fe742b64ce 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -56,7 +56,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/MetricController.java b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/MetricController.java
index da5b1d655de..352571ee434 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/PersonController.java b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/PersonController.java
index a778339280c..92d08bd8ee3 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/PersonController.java
@@ -32,6 +32,9 @@ Person person(@PathVariable Long id) {
     Sentry.addFeatureFlag("transaction-feature-flag", true);
     Span span = tracer.spanBuilder("spanCreatedThroughOtelApi").startSpan();
     try (final @NotNull Scope spanScope = span.makeCurrent()) {
+      Sentry.setAttribute("user.type", "admin");
+      Sentry.setAttribute("feature.version", 2);
+      Sentry.setAttribute("debug.enabled", true);
       Sentry.logger().warn("warn Sentry logging");
       Sentry.logger().error("error Sentry logging");
       Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index a4d7cc5bdc5..ad9b5f77b62 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -51,7 +51,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
index f7c7529525f..6b28e59d6a3 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
index d1a505d0e59..8e1108c3603 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/PersonController.java
@@ -23,6 +23,9 @@ public PersonController(PersonService personService) {
 
   @GetMapping("{id}")
   Person person(@PathVariable Long id) {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.logger().warn("warn Sentry logging");
     Sentry.logger().error("error Sentry logging");
     Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index a728fa7c314..3a2455a14fe 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -35,7 +35,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/MetricController.java b/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/MetricController.java
index da5b1d655de..352571ee434 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/PersonController.java b/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/PersonController.java
index d0b5435efc1..3816e45ab36 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/PersonController.java
@@ -23,6 +23,9 @@ public PersonController(PersonService personService) {
 
   @GetMapping("{id}")
   Person person(@PathVariable Long id) {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.logger().warn("warn Sentry logging");
     Sentry.logger().error("error Sentry logging");
     Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-webflux/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-webflux/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index a728fa7c314..3a2455a14fe 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -35,7 +35,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/MetricController.java b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/MetricController.java
index da5b1d655de..352571ee434 100644
--- a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/PersonController.java b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/PersonController.java
index 3bf03cb785f..c3475df14a6 100644
--- a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/PersonController.java
@@ -22,6 +22,9 @@ public PersonController(PersonService personService) {
 
   @GetMapping("{id}")
   Person person(@PathVariable Long id) {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.logger().warn("warn Sentry logging");
     Sentry.logger().error("error Sentry logging");
     Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index dc2ca2a10ae..039d9d640c7 100644
--- a/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index 0cae1acca40..a8ff439acf5 100644
--- a/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -40,7 +40,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-jakarta/src/main/java/io/sentry/samples/spring/jakarta/web/MetricController.java b/sentry-samples/sentry-samples-spring-jakarta/src/main/java/io/sentry/samples/spring/jakarta/web/MetricController.java
index 6c236a76a96..bb7f3fce64c 100644
--- a/sentry-samples/sentry-samples-spring-jakarta/src/main/java/io/sentry/samples/spring/jakarta/web/MetricController.java
+++ b/sentry-samples/sentry-samples-spring-jakarta/src/main/java/io/sentry/samples/spring/jakarta/web/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring-jakarta/src/main/java/io/sentry/samples/spring/jakarta/web/PersonController.java b/sentry-samples/sentry-samples-spring-jakarta/src/main/java/io/sentry/samples/spring/jakarta/web/PersonController.java
index ec33f360967..fdc11e1452b 100644
--- a/sentry-samples/sentry-samples-spring-jakarta/src/main/java/io/sentry/samples/spring/jakarta/web/PersonController.java
+++ b/sentry-samples/sentry-samples-spring-jakarta/src/main/java/io/sentry/samples/spring/jakarta/web/PersonController.java
@@ -23,6 +23,9 @@ public PersonController(PersonService personService) {
 
   @GetMapping("{id}")
   Person person(@PathVariable("id") Long id) {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.logger().warn("warn Sentry logging");
     Sentry.logger().error("error Sentry logging");
     Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index cef07e4866e..90e7a28fb36 100644
--- a/sentry-samples/sentry-samples-spring-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-jakarta/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index c806cf9b40e..af79ec8dc7e 100644
--- a/sentry-samples/sentry-samples-spring-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring-jakarta/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -35,7 +35,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring/src/main/java/io/sentry/samples/spring/web/MetricController.java b/sentry-samples/sentry-samples-spring/src/main/java/io/sentry/samples/spring/web/MetricController.java
index c0629ec137c..30ee8cbec42 100644
--- a/sentry-samples/sentry-samples-spring/src/main/java/io/sentry/samples/spring/web/MetricController.java
+++ b/sentry-samples/sentry-samples-spring/src/main/java/io/sentry/samples/spring/web/MetricController.java
@@ -16,6 +16,8 @@ public class MetricController {
 
   @GetMapping("count")
   String count() {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
     Sentry.metrics().count("countMetric");
     return "count metric increased";
   }
diff --git a/sentry-samples/sentry-samples-spring/src/main/java/io/sentry/samples/spring/web/PersonController.java b/sentry-samples/sentry-samples-spring/src/main/java/io/sentry/samples/spring/web/PersonController.java
index ee4020e0324..35fc4a8a1da 100644
--- a/sentry-samples/sentry-samples-spring/src/main/java/io/sentry/samples/spring/web/PersonController.java
+++ b/sentry-samples/sentry-samples-spring/src/main/java/io/sentry/samples/spring/web/PersonController.java
@@ -23,6 +23,9 @@ public PersonController(PersonService personService) {
 
   @GetMapping("{id}")
   Person person(@PathVariable("id") Long id) {
+    Sentry.setAttribute("user.type", "admin");
+    Sentry.setAttribute("feature.version", 2);
+    Sentry.setAttribute("debug.enabled", true);
     Sentry.logger().warn("warn Sentry logging");
     Sentry.logger().error("error Sentry logging");
     Sentry.logger().info("hello %s %s", "there", "world!");
diff --git a/sentry-samples/sentry-samples-spring/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt b/sentry-samples/sentry-samples-spring/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
index 6da3d98577e..8a5cd29fe6d 100644
--- a/sentry-samples/sentry-samples-spring/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring/src/test/kotlin/io/sentry/systemtest/MetricsSystemTest.kt
@@ -21,7 +21,9 @@ class MetricsSystemTest {
     assertEquals(200, restClient.lastKnownStatusCode)
 
     testHelper.ensureMetricsReceived { event, header ->
-      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0)
+      testHelper.doesContainMetric(event, "countMetric", "counter", 1.0) &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "user.type", "admin") &&
+        testHelper.doesMetricHaveAttribute(event, "countMetric", "feature.version", 2)
     }
   }
 
diff --git a/sentry-samples/sentry-samples-spring/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt b/sentry-samples/sentry-samples-spring/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
index 2a1a60793ac..0565ee5c33e 100644
--- a/sentry-samples/sentry-samples-spring/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
+++ b/sentry-samples/sentry-samples-spring/src/test/kotlin/io/sentry/systemtest/PersonSystemTest.kt
@@ -35,7 +35,20 @@ class PersonSystemTest {
     testHelper.ensureLogsReceived { logs, envelopeHeader ->
       testHelper.doesContainLogWithBody(logs, "warn Sentry logging") &&
         testHelper.doesContainLogWithBody(logs, "error Sentry logging") &&
-        testHelper.doesContainLogWithBody(logs, "hello there world!")
+        testHelper.doesContainLogWithBody(logs, "hello there world!") &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "user.type",
+          "admin",
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(
+          logs,
+          "warn Sentry logging",
+          "feature.version",
+          2,
+        ) &&
+        testHelper.doesLogWithBodyHaveAttribute(logs, "warn Sentry logging", "debug.enabled", true)
     }
   }
 

From d6f6aaab8833875c124eccca411449b7f0b917bd Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 10 Mar 2026 11:33:44 +0100
Subject: [PATCH 045/391] chore: Use GitHub native PR references in stack list
 format (#5166)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .cursor/rules/pr.mdc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.cursor/rules/pr.mdc b/.cursor/rules/pr.mdc
index df35ee3b944..d994b9adbba 100644
--- a/.cursor/rules/pr.mdc
+++ b/.cursor/rules/pr.mdc
@@ -206,9 +206,9 @@ Format:
 ```markdown
 ## PR Stack (<Topic>)
 
-- [#5118](https://github.com/getsentry/sentry-java/pull/5118) — Add scope-level attributes API
-- [#5120](https://github.com/getsentry/sentry-java/pull/5120) — Wire scope attributes into LoggerApi and MetricsApi
-- [#5121](https://github.com/getsentry/sentry-java/pull/5121) — Showcase scope attributes in Spring Boot 4 samples
+- #5118
+- #5120
+- #5121
 
 ---
 ```

From 97706653da8f48768ea2ec7893cd8b4b1ad0d129 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 10 Mar 2026 11:34:05 +0100
Subject: [PATCH 046/391] ref(docs): Avoid shell redirects in PR workflow docs
 (#5180)

Replace shell redirect examples (>, >>, |, &&) with Write/Edit tool
instructions in pr.mdc and create-java-pr skill. This prevents
permission prompt spam when agents update PR descriptions, since
compound shell commands don't match simple permission patterns.
---
 .claude/skills/create-java-pr/SKILL.md | 14 +++++++++-----
 .cursor/rules/pr.mdc                   | 16 +++++-----------
 2 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/.claude/skills/create-java-pr/SKILL.md b/.claude/skills/create-java-pr/SKILL.md
index cb2618e6477..6d5bb34edb3 100644
--- a/.claude/skills/create-java-pr/SKILL.md
+++ b/.claude/skills/create-java-pr/SKILL.md
@@ -123,6 +123,12 @@ Skip this step for standalone PRs.
 
 After creating the PR, update the PR description on **every other PR in the stack — including the collection branch PR** — so all PRs have the same up-to-date stack list. Follow the format and commands in `.cursor/rules/pr.mdc` § "Stack List in PR Description".
 
+**Important:** When updating PR bodies, never use shell redirects (`>`, `>>`) or pipes (`|`) or compound commands (`&&`). These create compound shell expressions that won't match permission patterns. Instead:
+- Use `gh pr view <NUMBER> --json body --jq '.body'` to get the body (output returned directly)
+- Use the `Write` tool to save it to a temp file
+- Use the `Edit` tool to modify the temp file
+- Use `gh pr edit <NUMBER> --body-file /tmp/pr-body.md` to update
+
 ## Step 6: Update Changelog
 
 First, determine whether a changelog entry is needed. **Skip this step** (and go straight to "No changelog needed" below) if the changes are not user-facing, for example:
@@ -173,8 +179,6 @@ git push
 
 If no changelog entry is needed, add `#skip-changelog` to the PR description to disable the changelog CI check:
 
-```bash
-gh pr view <PR_NUMBER> --json body --jq '.body' > /tmp/pr-body.md
-printf '\n#skip-changelog\n' >> /tmp/pr-body.md
-gh pr edit <PR_NUMBER> --body-file /tmp/pr-body.md
-```
+1. Get the current body: `gh pr view <PR_NUMBER> --json body --jq '.body'`
+2. Use the `Write` tool to save the output to `/tmp/pr-body.md`, appending `\n#skip-changelog\n` at the end
+3. Update: `gh pr edit <PR_NUMBER> --body-file /tmp/pr-body.md`
diff --git a/.cursor/rules/pr.mdc b/.cursor/rules/pr.mdc
index d994b9adbba..08a07511c67 100644
--- a/.cursor/rules/pr.mdc
+++ b/.cursor/rules/pr.mdc
@@ -223,19 +223,13 @@ No status column — GitHub already shows that. The `---` separates the stack li
 
 This does not apply to standalone PRs or the collection branch PR.
 
-To update the PR description, use `--body-file` to avoid shell quoting issues with special characters in the body:
+To update the PR description, use `--body-file` to avoid shell quoting issues with special characters in the body.
 
-```bash
-# Get current PR description into a temp file
-gh pr view <PR_NUMBER> --json body --jq '.body' > /tmp/pr-body.md
-
-# Edit /tmp/pr-body.md to prepend or replace the stack list section
-# (replace everything from "## PR Stack" up to and including the "---" separator,
-#  or prepend before the existing description if no stack list exists yet)
+**Important:** Do not use shell redirects (`>`, `>>`, `|`) or compound commands (`&&`, `||`). These create compound shell expressions that won't match permission patterns. Instead, use the `Write` and `Edit` tools for file manipulation:
 
-# Update the description
-gh pr edit <PR_NUMBER> --body-file /tmp/pr-body.md
-```
+1. Read the current body with `gh pr view <PR_NUMBER> --json body --jq '.body'` (the output is returned directly — use the `Write` tool to save it to `/tmp/pr-body.md`)
+2. Use the `Edit` tool to prepend or replace the stack list section in `/tmp/pr-body.md`
+3. Update the description: `gh pr edit <PR_NUMBER> --body-file /tmp/pr-body.md`
 
 ### Merging Stacked PRs (done by the user, not the agent)
 

From 092f017ff4d4477dbe6d9d5eb299368103d70ee8 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Wed, 11 Mar 2026 13:48:38 +0100
Subject: [PATCH 047/391] Fix Changelog (#5187)

* Fix Changelog

* Update CHANGELOG.md

Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>

* Update CHANGELOG with breaking change for ANR fingerprinting

Added breaking change for enableAnrFingerprinting option to reduce ANR noise.

---------

Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 CHANGELOG.md | 27 ++++++++++++++++++---------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 21fcd2aac74..10622bcaf8b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,23 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Android: Remove the dependency on protobuf-lite for tombstones ([#5157](https://github.com/getsentry/sentry-java/pull/5157))
+
+### Features
+
+- Add new experimental option to capture profiles for ANRs ([#4899](https://github.com/getsentry/sentry-java/pull/4899))
+  - This feature will capture a stack profile of the main thread when it gets unresponsive
+  - The profile gets attached to the ANR event on the next app start, providing a flamegraph of the ANR issue on the sentry issue details page
+  - Enable via `options.setAnrProfilingSampleRate(<sample-rate>)` or AndroidManifest.xml: `<meta-data android:name="io.sentry.anr.profiling.sample-rate" android:value="[0.0-1.0]" />`
+  - The sample rate controls the probability of collecting a profile for each detected foreground ANR (0.0 to 1.0, null to disable)
+- **Breaking:** Add `enableAnrFingerprinting` option to reduce ANR noise by assigning static fingerprints to ANR events with system-only stacktraces
+  - When enabled, ANRs whose stacktraces contain only system frames (e.g. `java.lang` or `android.os`) are grouped into a single issue instead of creating many separate issues
+  - **IMPORTANT:** This option is enabled by default.
+  - Disable via `options.setEnableAnrFingerprinting(false)` or AndroidManifest.xml: `<meta-data android:name="io.sentry.anr.enable-fingerprinting" android:value="false" />`
+
 ## 8.34.1
 
 ### Fixes
@@ -7,7 +25,6 @@
 - Common: Finalize previous session even when auto session tracking is disabled ([#5154](https://github.com/getsentry/sentry-java/pull/5154))
 - Android: Add `filterTouchesWhenObscured` to prevent Tapjacking on user feedback dialog ([#5155](https://github.com/getsentry/sentry-java/pull/5155))
 - Android: Add proguard rules to prevent error about missing Replay classes ([#5153](https://github.com/getsentry/sentry-java/pull/5153))
-- Android: Remove the dependency on protobuf-lite for tombstones ([#5157](https://github.com/getsentry/sentry-java/pull/5157))
 
 ## 8.34.0
 
@@ -46,14 +63,6 @@
     <meta-data android:name="io.sentry.screenshot.mask-all-images" android:value="true" />
     ```
 - The `ManifestMetaDataReader` now read the `DIST` ([#5107](https://github.com/getsentry/sentry-java/pull/5107))
-- Add new experimental option to capture profiles for ANRs ([#4899](https://github.com/getsentry/sentry-java/pull/4899))
-  - This feature will capture a stack profile of the main thread when it gets unresponsive
-  - The profile gets attached to the ANR event on the next app start, providing a flamegraph of the ANR issue on the sentry issue details page
-  - Enable via `options.setAnrProfilingSampleRate(<sample-rate>)` or AndroidManifest.xml: `<meta-data android:name="io.sentry.anr.profiling.sample-rate" android:value="[0.0-1.0]" />`
-  - The sample rate controls the probability of collecting a profile for each detected foreground ANR (0.0 to 1.0, null to disable)
-- Add `enableAnrFingerprinting` option to reduce ANR noise by assigning static fingerprints to ANR events with system-only stacktraces
-  - When enabled, ANRs whose stacktraces contain only system frames (e.g. `java.lang` or `android.os`) are grouped into a single issue instead of creating many separate issues
-  - Enable via `options.setEnableAnrFingerprinting(true)` or AndroidManifest.xml: `<meta-data android:name="io.sentry.anr.enable-fingerprinting" android:value="true" />`
 
 ### Fixes
 

From 8733a069bc803db54d18fa059741ae5be4830d20 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Thu, 12 Mar 2026 10:05:02 +0100
Subject: [PATCH 048/391] Refine Changelog for enableAnrFingerprinting option
 (#5188)

* Refine Changelog for enableAnrFingerprinting option

#skip-changelog

* Apply suggestion from @romtsn

---------

Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 CHANGELOG.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 10622bcaf8b..c6c5ca83377 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,8 +13,12 @@
   - The profile gets attached to the ANR event on the next app start, providing a flamegraph of the ANR issue on the sentry issue details page
   - Enable via `options.setAnrProfilingSampleRate(<sample-rate>)` or AndroidManifest.xml: `<meta-data android:name="io.sentry.anr.profiling.sample-rate" android:value="[0.0-1.0]" />`
   - The sample rate controls the probability of collecting a profile for each detected foreground ANR (0.0 to 1.0, null to disable)
-- **Breaking:** Add `enableAnrFingerprinting` option to reduce ANR noise by assigning static fingerprints to ANR events with system-only stacktraces
+
+### Behavioral Changes
+
+- Add `enableAnrFingerprinting` option which assigns static fingerprints to ANR events with system-only stacktraces
   - When enabled, ANRs whose stacktraces contain only system frames (e.g. `java.lang` or `android.os`) are grouped into a single issue instead of creating many separate issues
+  - This will help to reduce overall ANR issue noise in the Sentry dashboard
   - **IMPORTANT:** This option is enabled by default.
   - Disable via `options.setEnableAnrFingerprinting(false)` or AndroidManifest.xml: `<meta-data android:name="io.sentry.anr.enable-fingerprinting" android:value="false" />`
 

From 7f68594fbbac019924a69fddac1cdc3e4dadcfa5 Mon Sep 17 00:00:00 2001
From: markushi <1411808+markushi@users.noreply.github.com>
Date: Thu, 12 Mar 2026 09:07:04 +0000
Subject: [PATCH 049/391] release: 8.35.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c6c5ca83377..54dff9fef7f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.35.0
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index db7fab6765c..05e47bc6ade 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.9.0
 
 # Release information
-versionName=8.34.1
+versionName=8.35.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 3c621a2cd466909cd8ac19629b6eceac7c9a7622 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Mar 2026 11:19:49 +0100
Subject: [PATCH 050/391] build(deps): bump
 reactivecircus/android-emulator-runner from 2.35.0 to 2.37.0 (#5194)

Bumps [reactivecircus/android-emulator-runner](https://github.com/reactivecircus/android-emulator-runner) from 2.35.0 to 2.37.0.
- [Release notes](https://github.com/reactivecircus/android-emulator-runner/releases)
- [Changelog](https://github.com/ReactiveCircus/android-emulator-runner/blob/main/CHANGELOG.md)
- [Commits](https://github.com/reactivecircus/android-emulator-runner/compare/b530d96654c385303d652368551fb075bc2f0b6b...e89f39f1abbbd05b1113a29cf4db69e7540cae5a)

---
updated-dependencies:
- dependency-name: reactivecircus/android-emulator-runner
  dependency-version: 2.37.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 4 ++--
 .github/workflows/integration-tests-ui-critical.yml | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index d5f326b56bf..c6bee353d83 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -60,7 +60,7 @@ jobs:
 
       - name: Create AVD and generate snapshot for caching
         if: steps.avd-cache.outputs.cache-hit != 'true'
-        uses: reactivecircus/android-emulator-runner@b530d96654c385303d652368551fb075bc2f0b6b # pin@v2
+        uses: reactivecircus/android-emulator-runner@e89f39f1abbbd05b1113a29cf4db69e7540cae5a # pin@v2
         with:
           api-level: 30
           target: aosp_atd
@@ -79,7 +79,7 @@ jobs:
 
       # We tried to use the cache action to cache gradle stuff, but it made tests slower and timeout
       - name: Run instrumentation tests
-        uses: reactivecircus/android-emulator-runner@b530d96654c385303d652368551fb075bc2f0b6b # pin@v2
+        uses: reactivecircus/android-emulator-runner@e89f39f1abbbd05b1113a29cf4db69e7540cae5a # pin@v2
         with:
           api-level: 30
           target: aosp_atd
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 77691bfd65b..04e7f834f1f 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -100,7 +100,7 @@ jobs:
 
       - name: Create AVD and generate snapshot for caching
         if: steps.avd-cache.outputs.cache-hit != 'true'
-        uses: reactivecircus/android-emulator-runner@b530d96654c385303d652368551fb075bc2f0b6b # pin@v2
+        uses: reactivecircus/android-emulator-runner@e89f39f1abbbd05b1113a29cf4db69e7540cae5a # pin@v2
         with:
           api-level: ${{ matrix.api-level }}
           target: ${{ matrix.target }}
@@ -124,7 +124,7 @@ jobs:
           version: ${{env.MAESTRO_VERSION}}
 
       - name: Run tests
-        uses: reactivecircus/android-emulator-runner@b530d96654c385303d652368551fb075bc2f0b6b # pin@v2.35.0
+        uses: reactivecircus/android-emulator-runner@e89f39f1abbbd05b1113a29cf4db69e7540cae5a # pin@v2.37.0
         with:
           api-level: ${{ matrix.api-level }}
           target: ${{ matrix.target }}

From 139023e3fb465e82b9dd23b235aecc457387e05a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Mar 2026 11:20:08 +0100
Subject: [PATCH 051/391] build(deps): bump getsentry/craft from 2.23.1 to
 2.24.1 (#5197)

Bumps [getsentry/craft](https://github.com/getsentry/craft) from 2.23.1 to 2.24.1.
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/d4cfac9d25d1fc72c9241e5d22aff559a114e4e9...013a7b2113c2cac0ff32d5180cfeaefc7c9ce5b6)

---
updated-dependencies:
- dependency-name: getsentry/craft
  dependency-version: 2.24.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index df09bf89706..5dfe3944e78 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@d4cfac9d25d1fc72c9241e5d22aff559a114e4e9 # v2
+        uses: getsentry/craft@013a7b2113c2cac0ff32d5180cfeaefc7c9ce5b6 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From adaff665437f3faa1fc5ec84aa770e5eec73ac1e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Mar 2026 11:23:43 +0100
Subject: [PATCH 052/391] build(deps): bump actions/create-github-app-token
 from 2.2.1 to 3.0.0 (#5196)

Bumps [actions/create-github-app-token](https://github.com/actions/create-github-app-token) from 2.2.1 to 3.0.0.
- [Release notes](https://github.com/actions/create-github-app-token/releases)
- [Commits](https://github.com/actions/create-github-app-token/compare/29824e69f54612133e76f7eaac726eef6c875baf...f8d387b68d61c58ab83c6c016672934102569859)

---
updated-dependencies:
- dependency-name: actions/create-github-app-token
  dependency-version: 3.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 5dfe3944e78..f7c530df16a 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -23,7 +23,7 @@ jobs:
     steps:
       - name: Get auth token
         id: token
-        uses: actions/create-github-app-token@29824e69f54612133e76f7eaac726eef6c875baf # v2.2.1
+        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v3.0.0
         with:
           app-id: ${{ vars.SENTRY_RELEASE_BOT_CLIENT_ID }}
           private-key: ${{ secrets.SENTRY_RELEASE_BOT_PRIVATE_KEY }}

From 01540d6015e9a2253e983a8c4d0cf1d7198f5813 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Mar 2026 11:24:02 +0100
Subject: [PATCH 053/391] build(deps): bump dorny/paths-filter from 3.0.2 to
 4.0.1 (#5195)

Bumps [dorny/paths-filter](https://github.com/dorny/paths-filter) from 3.0.2 to 4.0.1.
- [Release notes](https://github.com/dorny/paths-filter/releases)
- [Changelog](https://github.com/dorny/paths-filter/blob/master/CHANGELOG.md)
- [Commits](https://github.com/dorny/paths-filter/compare/de90cc6fb38fc0963ad72b210f1f284cd68cea36...fbd0ab8f3e69293af611ebaee6363fc25e6d187d)

---
updated-dependencies:
- dependency-name: dorny/paths-filter
  dependency-version: 4.0.1
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/changes-in-high-risk-code.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/changes-in-high-risk-code.yml b/.github/workflows/changes-in-high-risk-code.yml
index ba1376ff513..5da9f52cb50 100644
--- a/.github/workflows/changes-in-high-risk-code.yml
+++ b/.github/workflows/changes-in-high-risk-code.yml
@@ -19,7 +19,7 @@ jobs:
       - uses: actions/checkout@v6
       - name: Get changed files
         id: changes
-        uses: dorny/paths-filter@de90cc6fb38fc0963ad72b210f1f284cd68cea36 # v3.0.2
+        uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
         with:
           token: ${{ github.token }}
           filters: .github/file-filters.yml

From 5183932caab97d2c556bb49cc15e1643361b733b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Mar 2026 11:24:50 +0100
Subject: [PATCH 054/391] build(deps): bump github/codeql-action from 4.32.4 to
 4.32.6 (#5170)

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.32.4 to 4.32.6.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/89a39a4e59826350b863aa6b6252a07ad50cf83e...0d579ffd059c29b07949a3cce3983f0780820c98)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-version: 4.32.6
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql-analysis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index ffd4082904d..703c4abe043 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@89a39a4e59826350b863aa6b6252a07ad50cf83e # pin@v2
+        uses: github/codeql-action/init@0d579ffd059c29b07949a3cce3983f0780820c98 # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@89a39a4e59826350b863aa6b6252a07ad50cf83e # pin@v2
+        uses: github/codeql-action/analyze@0d579ffd059c29b07949a3cce3983f0780820c98 # pin@v2

From b4edb46ebd6de4d5d8d8f1fdc330cd67408778d1 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 16 Mar 2026 10:30:05 +0000
Subject: [PATCH 055/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.13.2 (#5181)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 8 ++++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 54dff9fef7f..75cc2dabd21 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+### Dependencies
+
+- Bump Native SDK from v0.13.1 to v0.13.2 ([#5181](https://github.com/getsentry/sentry-java/pull/5181))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0132)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.13.1...0.13.2)
+
 ## 8.35.0
 
 ### Fixes
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 61fbefd9152..db43203d345 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -148,7 +148,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.1" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.2" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 591440417797100355fd8cbaa353ea084ccfa5cb Mon Sep 17 00:00:00 2001
From: Lukas Bloder <lukas.bloder@gmail.com>
Date: Mon, 16 Mar 2026 16:41:34 +0100
Subject: [PATCH 056/391] Add AI rules files for Profiling (#5034)

* add cursor rules for the profiling feature

* add profiling info to overview_dev.mdc

* split jvm and android profiling

* remove profiling android rules, improve jvm rules, improve file name
---
 .cursor/rules/continuous_profiling_jvm.mdc | 174 +++++++++++++++++++++
 .cursor/rules/overview_dev.mdc             |  18 ++-
 2 files changed, 190 insertions(+), 2 deletions(-)
 create mode 100644 .cursor/rules/continuous_profiling_jvm.mdc

diff --git a/.cursor/rules/continuous_profiling_jvm.mdc b/.cursor/rules/continuous_profiling_jvm.mdc
new file mode 100644
index 00000000000..d9a911de25e
--- /dev/null
+++ b/.cursor/rules/continuous_profiling_jvm.mdc
@@ -0,0 +1,174 @@
+---
+alwaysApply: false
+description: JVM Continuous Profiling (sentry-async-profiler)
+---
+# JVM Continuous Profiling
+
+Use this rule when working on JVM continuous profiling in `sentry-async-profiler` and the related core profiling abstractions in `sentry`.
+
+This area is suitable for LLM work, but do not rely on this rule alone for behavior changes. Always read the implementation and nearby tests first, especially for sampling, lifecycle, rate limiting, and file cleanup behavior.
+
+## Module Structure
+
+- **`sentry-async-profiler`**: standalone module containing the async-profiler integration
+  - Uses Java `ServiceLoader` discovery
+  - No direct dependency from core `sentry` module
+  - Enabled by adding the module as a dependency
+
+- **`sentry` core abstractions**:
+  - `IContinuousProfiler`: profiler lifecycle interface
+  - `ProfileChunk`: profile chunk payload sent to Sentry
+  - `IProfileConverter`: converts JVM JFR files into `SentryProfile`
+  - `ProfileLifecycle`: controls MANUAL vs TRACE lifecycle
+  - `ProfilingServiceLoader`: loads profiler and converter implementations via `ServiceLoader`
+
+## Key Classes
+
+### `JavaContinuousProfiler` (`sentry-async-profiler`)
+- Wraps the native async-profiler library
+- Writes JFR files to `profilingTracesDirPath`
+- Rotates chunks periodically via `MAX_CHUNK_DURATION_MILLIS` (currently 10s)
+- Implements `RateLimiter.IRateLimitObserver`
+- Maintains `rootSpanCounter` for TRACE lifecycle
+- Keeps a session-level `profilerId` across chunks until the profiling session ends
+- `getChunkId()` currently returns `SentryId.EMPTY_ID`, but emitted `ProfileChunk`s get a fresh chunk id when built in `stop(...)`
+
+### `ProfileChunk`
+- Carries `profilerId`, `chunkId`, timestamp, platform, measurements, and a JFR file reference
+- Built via `ProfileChunk.Builder`
+- For JVM, the JFR file is converted later during envelope item creation, not inside `JavaContinuousProfiler`
+
+### `ProfileLifecycle`
+- `MANUAL`: explicit `Sentry.startProfiler()` / `Sentry.stopProfiler()`
+- `TRACE`: profiler lifecycle follows active sampled root spans
+
+## Configuration
+
+Continuous profiling is **not** controlled by `profilesSampleRate`.
+
+Key options:
+- **`profileSessionSampleRate`**: session-level sample rate for continuous profiling
+- **`profileLifecycle`**: `ProfileLifecycle.MANUAL` (default) or `ProfileLifecycle.TRACE`
+- **`cacheDirPath`**: base SDK cache directory; profiling traces are written under the derived `profilingTracesDirPath`
+- **`profilingTracesHz`**: sampling frequency in Hz (default: 101)
+
+Continuous profiling is enabled when:
+- `profilesSampleRate == null`
+- `profilesSampler == null`
+- `profileSessionSampleRate != null && profileSessionSampleRate > 0`
+
+Example:
+
+```java
+options.setProfileSessionSampleRate(1.0);
+options.setCacheDirPath("/tmp/sentry-cache");
+options.setProfileLifecycle(ProfileLifecycle.MANUAL);
+options.setProfilingTracesHz(101);
+```
+
+## How It Works
+
+### Initialization
+- `InitUtil.initializeProfiler(...)` resolves or creates the profiling traces directory
+- `ProfilingServiceLoader.loadContinuousProfiler(...)` uses `ServiceLoader` to find `JavaContinuousProfilerProvider`
+- `AsyncProfilerContinuousProfilerProvider` instantiates `JavaContinuousProfiler`
+- `ProfilingServiceLoader.loadProfileConverter()` separately loads the `JavaProfileConverterProvider`
+
+### Profiling Flow
+
+**Start**
+- Sampling decision is made via `TracesSampler.sampleSessionProfile(...)`
+- Sampling is session-based and cached until `reevaluateSampling()`
+- Scopes and rate limiter are initialized lazily via `initScopes()`
+- Rate limits for `All` or `ProfileChunk` abort startup
+- JFR filename is generated under `profilingTracesDirPath`
+- async-profiler is started with a command like:
+  - `start,jfr,event=wall,nobatch,interval=<interval>,file=<path>`
+- Automatic chunk stop is scheduled after `MAX_CHUNK_DURATION_MILLIS`
+
+**Chunk Rotation**
+- `stop(true)` stops async-profiler and validates the JFR file
+- A `ProfileChunk.Builder` is created with:
+  - current `profilerId`
+  - a fresh `chunkId`
+  - trace file
+  - chunk timestamp
+  - platform `java`
+- Builder is buffered in `payloadBuilders`
+- Chunks are sent if scopes are available
+- Profiling is restarted for the next chunk
+
+**Stop**
+- `MANUAL`: stop immediately, do not restart, reset `profilerId`
+- `TRACE`: decrement `rootSpanCounter`; stop only when it reaches 0
+- `close(...)` also forces shutdown and resets TRACE state
+
+### Sending and Conversion
+- `JavaContinuousProfiler` buffers `ProfileChunk.Builder` instances
+- `sendChunks(...)` builds `ProfileChunk` objects and calls `scopes.captureProfileChunk(...)`
+- `SentryClient.captureProfileChunk(...)` creates an envelope item
+- JVM JFR-to-`SentryProfile` conversion happens in `SentryEnvelopeItem.fromProfileChunk(...)` using the loaded `IProfileConverter`
+- Trace files are deleted in the envelope item path after serialization attempts
+
+## TRACE Mode Lifecycle
+- `rootSpanCounter` increments when sampled root spans start
+- `rootSpanCounter` decrements when root spans finish
+- Profiler runs while `rootSpanCounter > 0`
+- Multiple concurrent sampled transactions can share the same profiling session
+- Be careful when changing lifecycle logic: this area is lock-protected and concurrency-sensitive
+
+## Rate Limiting and Buffering
+
+### Rate Limiting
+- Registers as a `RateLimiter.IRateLimitObserver`
+- If rate limited for `ProfileChunk` or `All`:
+  - profiler stops immediately
+  - it does not auto-restart when the limit expires
+- Startup also checks rate limiting before profiling begins
+
+### Buffering / pre-init behavior
+- JFR files are written to `profilingTracesDirPath` and marked `deleteOnExit()` when a chunk is accepted
+- If scopes are not yet available, `ProfileChunk.Builder`s remain buffered in memory in `payloadBuilders`
+- This commonly matters for profiling that starts before SDK scopes are ready
+- This is not a dedicated durable offline queue owned by the profiler itself; conversion and final send happen later in the normal client/envelope path
+
+## Extending
+
+To add or replace JVM profiler implementations:
+- implement `IContinuousProfiler`
+- implement `JavaContinuousProfilerProvider`
+- register provider in:
+  - `META-INF/services/io.sentry.profiling.JavaContinuousProfilerProvider`
+
+To add or replace JVM profile conversion:
+- implement `IProfileConverter`
+- implement `JavaProfileConverterProvider`
+- register provider in:
+  - `META-INF/services/io.sentry.profiling.JavaProfileConverterProvider`
+
+## Code Locations
+
+Primary implementation:
+- `sentry/src/main/java/io/sentry/IContinuousProfiler.java`
+- `sentry/src/main/java/io/sentry/ProfileChunk.java`
+- `sentry/src/main/java/io/sentry/profiling/ProfilingServiceLoader.java`
+- `sentry/src/main/java/io/sentry/util/InitUtil.java`
+- `sentry/src/main/java/io/sentry/SentryEnvelopeItem.java`
+- `sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/profiling/JavaContinuousProfiler.java`
+- `sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/provider/AsyncProfilerContinuousProfilerProvider.java`
+- `sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/provider/AsyncProfilerProfileConverterProvider.java`
+- `sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverter.java`
+
+Tests to read first:
+- `sentry-async-profiler/src/test/java/io/sentry/asyncprofiler/profiling/JavaContinuousProfilerTest.kt`
+- `sentry-async-profiler/src/test/java/io/sentry/asyncprofiler/JavaContinuousProfilingServiceLoaderTest.kt`
+- `sentry-async-profiler/src/test/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverterTest.kt`
+
+## LLM Guidance
+
+This rule is good enough for orientation, but for actual code changes always verify:
+- the sampling path in `TracesSampler`
+- continuous profiling enablement in `SentryOptions`
+- lifecycle entry points in `Scopes` and `SentryTracer`
+- conversion and file deletion behavior in `SentryEnvelopeItem`
+- existing tests before changing concurrency or lifecycle semantics
diff --git a/.cursor/rules/overview_dev.mdc b/.cursor/rules/overview_dev.mdc
index a982cfe960e..17ce98f07be 100644
--- a/.cursor/rules/overview_dev.mdc
+++ b/.cursor/rules/overview_dev.mdc
@@ -30,7 +30,7 @@ Use the `fetch_rules` tool to include these rules when working on specific areas
 
 - **`scopes`**: Use when working with:
   - Hub/Scope management, forking, or lifecycle
-  - `Sentry.getCurrentScopes()`, `pushScope()`, `withScope()` 
+  - `Sentry.getCurrentScopes()`, `pushScope()`, `withScope()`
   - `ScopeType` (GLOBAL, ISOLATION, CURRENT)
   - Thread-local storage, scope bleeding issues
   - Migration from Hub API (v7 → v8)
@@ -66,6 +66,18 @@ Use the `fetch_rules` tool to include these rules when working on specific areas
   - `SentryMetricsEvent`, `SentryMetricsEvents`
   - `SentryOptions.getMetrics()`, `beforeSend` callback
 
+- **`continuous_profiling_jvm`**: Use when working with:
+  - JVM continuous profiling (`sentry-async-profiler` module)
+  - `IContinuousProfiler`, `JavaContinuousProfiler`
+  - `ProfileChunk`, chunk rotation, JFR file handling
+  - `ProfileLifecycle` (MANUAL vs TRACE modes)
+  - async-profiler integration, ServiceLoader discovery
+  - Rate limiting, offline caching, scopes integration
+
+- **Android profiling**: There is currently no dedicated rule for this area yet.
+  - Inspect the relevant `sentry-android-core` profiling code directly
+  - Fetch other related rules as needed (for example `options`, `offline`, or `api`)
+
 ### Integration & Infrastructure
 - **`opentelemetry`**: Use when working with:
   - OpenTelemetry modules (`sentry-opentelemetry-*`)
@@ -99,7 +111,7 @@ Use the `fetch_rules` tool to include these rules when working on specific areas
    - Public API/apiDump/.api files/binary compatibility/new method → `api`
    - Options/SentryOptions/ExternalOptions/ManifestMetadataReader/sentry.properties → `options`
    - Scope/Hub/forking → `scopes`
-   - Duplicate/dedup → `deduplication` 
+   - Duplicate/dedup → `deduplication`
    - OpenTelemetry/tracing/spans → `opentelemetry`
    - new module/integration/sample → `new_module`
    - Cache/offline/network → `offline`
@@ -107,3 +119,5 @@ Use the `fetch_rules` tool to include these rules when working on specific areas
    - Feature flag/addFeatureFlag/flag evaluation → `feature_flags`
    - Metrics/count/distribution/gauge → `metrics`
    - PR/pull request/stacked PR/stack → `pr`
+   - JVM continuous profiling/async-profiler/JFR/ProfileChunk → `continuous_profiling_jvm`
+   - Android continuous profiling/AndroidProfiler/frame metrics/method tracing → no dedicated rule yet; inspect the code directly

From 37ec571aad40d714af14c5107647a22895550e83 Mon Sep 17 00:00:00 2001
From: Mischan Toosarani-Hausberger <mischan@abovevacant.com>
Date: Mon, 16 Mar 2026 17:14:42 +0100
Subject: [PATCH 057/391] fix(android): bump epitaph to 0.1.1 (#5200)

---
 CHANGELOG.md              | 3 +++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 75cc2dabd21..bf7c919c957 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,9 @@
 - Bump Native SDK from v0.13.1 to v0.13.2 ([#5181](https://github.com/getsentry/sentry-java/pull/5181))
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0132)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.13.1...0.13.2)
+- Bump `com.abovevacant:epitaph` to `0.1.1` to avoid old D8/R8 dexing crashes in downstream Android builds on old AGP versions such as 7.4.x. ([#5200](https://github.com/getsentry/sentry-java/pull/5200))
+  - [changelog](https://github.com/abovevacant/epitaph/blob/main/CHANGELOG.md#011---2026-03-16)
+  - [diff](https://github.com/abovevacant/epitaph/compare/v0.1.0...v0.1.1)
 
 ## 8.35.0
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index db43203d345..f81aea8a674 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -143,7 +143,7 @@ otel-javaagent-extension-api = { module = "io.opentelemetry.javaagent:openteleme
 otel-semconv = { module = "io.opentelemetry.semconv:opentelemetry-semconv", version.ref = "otelSemanticConventions" }
 otel-semconv-incubating = { module = "io.opentelemetry.semconv:opentelemetry-semconv-incubating", version.ref = "otelSemanticConventionsAlpha" }
 p6spy = { module = "p6spy:p6spy", version = "3.9.1" }
-epitaph = { module = "com.abovevacant:epitaph", version = "0.1.0" }
+epitaph = { module = "com.abovevacant:epitaph", version = "0.1.1" }
 quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }

From 9c1b40670ab44bcb38abef3414e06685611f123a Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Tue, 17 Mar 2026 11:41:39 +0100
Subject: [PATCH 058/391] Support apps compiled against Jetpack Compose 1.10
 (#5189)

* Compile against JPC 1.10

* Format code

* Fix click/scroll target detection

* Update Changelog

* Move changes into replay module

* Switch to reflection

* Fix Changelog

* Improve LayoutNode iteration

* Fix tag propagation

* Add tests

* Address PR feedback

* Format code

* Update CHANGELOG for Jetpack Compose and SDK version

* return first tag instead of last one

* Fix exception propagation

* Return first non-null tag

* Allow nullable semantics in case there are really none

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |   4 +
 gradle/libs.versions.toml                     |   2 +-
 .../viewhierarchy/ComposeViewHierarchyNode.kt |  47 +-
 .../viewhierarchy/SentryLayoutNodeHelper.kt   |  90 +++
 .../ComposeMaskingOptionsTest.kt              |   3 +-
 .../gestures/ComposeGestureTargetLocator.kt   | 104 +--
 .../foundation/GestureModifierStubs.kt        |  15 +
 .../ComposeGestureTargetLocatorTest.kt        | 703 ++++++++++++++++++
 8 files changed, 891 insertions(+), 77 deletions(-)
 create mode 100644 sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/SentryLayoutNodeHelper.kt
 create mode 100644 sentry-compose/src/androidUnitTest/kotlin/androidx/compose/foundation/GestureModifierStubs.kt
 create mode 100644 sentry-compose/src/androidUnitTest/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocatorTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bf7c919c957..866a450519a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+
+- Support masking/unmasking and click/scroll detection for Jetpack Compose 1.10+ ([#5189](https://github.com/getsentry/sentry-java/pull/5189))
+
 ### Dependencies
 
 - Bump Native SDK from v0.13.1 to v0.13.2 ([#5181](https://github.com/getsentry/sentry-java/pull/5181))
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index f81aea8a674..d659e43438c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -85,7 +85,7 @@ androidx-compose-material-icons-core = { module = "androidx.compose.material:mat
 androidx-compose-material-icons-extended = { module = "androidx.compose.material:material-icons-extended", version="1.7.8" }
 androidx-compose-ui = { module = "androidx.compose.ui:ui", version.ref = "androidxCompose" }
 # Note: don't change without testing forwards compatibility
-androidx-compose-ui-replay = { module = "androidx.compose.ui:ui", version = "1.5.0" }
+androidx-compose-ui-replay = { module = "androidx.compose.ui:ui", version = "1.10.2" }
 androidx-constraintlayout = { module = "androidx.constraintlayout:constraintlayout", version = "2.1.3" }
 androidx-core = { module = "androidx.core:core", version = "1.3.2" }
 androidx-core-ktx = { module = "androidx.core:core-ktx", version = "1.7.0" }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
index 2e58418c3ac..f421ff9ad07 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
@@ -36,32 +36,35 @@ import java.lang.reflect.Method
 @SuppressLint("UseRequiresApi")
 @TargetApi(26)
 internal object ComposeViewHierarchyNode {
-  private val getSemanticsConfigurationMethod: Method? by lazy {
-    try {
-      return@lazy LayoutNode::class.java.getDeclaredMethod("getSemanticsConfiguration").apply {
-        isAccessible = true
+  private val getCollapsedSemanticsMethod: Method? by
+    lazy(LazyThreadSafetyMode.NONE) {
+      try {
+        return@lazy LayoutNode::class
+          .java
+          .getDeclaredMethod("getCollapsedSemantics\$ui_release")
+          .apply { isAccessible = true }
+      } catch (_: Throwable) {
+        // ignore, as this method may not be available
       }
-    } catch (_: Throwable) {
-      // ignore, as this method may not be available
+      return@lazy null
     }
-    return@lazy null
-  }
 
   private var semanticsRetrievalErrorLogged: Boolean = false
 
   @JvmStatic
   internal fun retrieveSemanticsConfiguration(node: LayoutNode): SemanticsConfiguration? {
-    // Jetpack Compose 1.8 or newer provides SemanticsConfiguration via SemanticsInfo
-    // See
-    // https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/node/LayoutNode.kt
-    // and
-    // https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/semantics/SemanticsInfo.kt
-    getSemanticsConfigurationMethod?.let {
-      return it.invoke(node) as SemanticsConfiguration?
+    return try {
+      node.semanticsConfiguration
+    } catch (t: Throwable) {
+      // for backwards compatibility
+      // Jetpack Compose 1.8 or older
+      if (getCollapsedSemanticsMethod != null) {
+        getCollapsedSemanticsMethod!!.invoke(node) as SemanticsConfiguration?
+      } else {
+        // re-throw t if there's no way to retrieve semantics
+        throw t
+      }
     }
-
-    // for backwards compatibility
-    return node.collapsedSemantics
   }
 
   /**
@@ -136,7 +139,7 @@ internal object ComposeViewHierarchyNode {
           """
                     Error retrieving semantics information from Compose tree. Most likely you're using
                     an unsupported version of androidx.compose.ui:ui. The supported
-                    version range is 1.5.0 - 1.8.0.
+                    version range is 1.5.0 - 1.10.2.
                     If you're using a newer version, please open a github issue with the version
                     you're using, so we can add support for it.
                     """
@@ -157,7 +160,7 @@ internal object ComposeViewHierarchyNode {
         shouldMask = true,
         isImportantForContentCapture = false, // will be set by children
         isVisible =
-          !node.outerCoordinator.isTransparent() &&
+          !SentryLayoutNodeHelper.isTransparent(node) &&
             visibleRect.height() > 0 &&
             visibleRect.width() > 0,
         visibleRect = visibleRect,
@@ -165,7 +168,7 @@ internal object ComposeViewHierarchyNode {
     }
 
     val isVisible =
-      !node.outerCoordinator.isTransparent() &&
+      !SentryLayoutNodeHelper.isTransparent(node) &&
         (semantics == null || !semantics.contains(SemanticsProperties.InvisibleToUser)) &&
         visibleRect.height() > 0 &&
         visibleRect.width() > 0
@@ -301,7 +304,7 @@ internal object ComposeViewHierarchyNode {
     options: SentryMaskingOptions,
     logger: ILogger,
   ) {
-    val children = this.children
+    val children = SentryLayoutNodeHelper.getChildren(this)
     if (children.isEmpty()) {
       return
     }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/SentryLayoutNodeHelper.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/SentryLayoutNodeHelper.kt
new file mode 100644
index 00000000000..6cfe5ec6fc0
--- /dev/null
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/SentryLayoutNodeHelper.kt
@@ -0,0 +1,90 @@
+@file:Suppress(
+  "INVISIBLE_MEMBER",
+  "INVISIBLE_REFERENCE",
+  "EXPOSED_PARAMETER_TYPE",
+  "EXPOSED_RETURN_TYPE",
+  "EXPOSED_FUNCTION_RETURN_TYPE",
+)
+
+package io.sentry.android.replay.viewhierarchy
+
+import androidx.compose.ui.node.LayoutNode
+import androidx.compose.ui.node.NodeCoordinator
+import java.lang.reflect.Method
+
+/**
+ * Provides access to internal LayoutNode members that are subject to Kotlin name-mangling.
+ *
+ * This class is not thread-safe, as Compose UI operations are expected to be performed on the main
+ * thread.
+ *
+ * Compiled against Compose >= 1.10 where the mangled names use the "ui" module suffix (e.g.
+ * getChildren$ui()). For apps still on Compose < 1.10 (where the suffix is "$ui_release"), the
+ * direct call will throw [NoSuchMethodError] and we fall back to reflection-based accessors that
+ * are resolved and cached on first use.
+ */
+internal object SentryLayoutNodeHelper {
+  private class Fallback(val getChildren: Method?, val getOuterCoordinator: Method?)
+
+  private var useFallback: Boolean? = null
+  private var fallback: Fallback? = null
+
+  private fun tryResolve(clazz: Class<*>, name: String): Method? {
+    return try {
+      clazz.getDeclaredMethod(name).apply { isAccessible = true }
+    } catch (_: NoSuchMethodException) {
+      null
+    }
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  fun getChildren(node: LayoutNode): List<LayoutNode> {
+    when (useFallback) {
+      false -> return node.children
+      true -> {
+        return getFallback().getChildren!!.invoke(node) as List<LayoutNode>
+      }
+      null -> {
+        try {
+          return node.children.also { useFallback = false }
+        } catch (_: NoSuchMethodError) {
+          useFallback = true
+          return getFallback().getChildren!!.invoke(node) as List<LayoutNode>
+        }
+      }
+    }
+  }
+
+  fun isTransparent(node: LayoutNode): Boolean {
+    when (useFallback) {
+      false -> return node.outerCoordinator.isTransparent()
+      true -> {
+        val fb = getFallback()
+        val coordinator = fb.getOuterCoordinator!!.invoke(node) as NodeCoordinator
+        return coordinator.isTransparent()
+      }
+      null -> {
+        try {
+          return node.outerCoordinator.isTransparent().also { useFallback = false }
+        } catch (_: NoSuchMethodError) {
+          useFallback = true
+          val fb = getFallback()
+          val coordinator = fb.getOuterCoordinator!!.invoke(node) as NodeCoordinator
+          return coordinator.isTransparent()
+        }
+      }
+    }
+  }
+
+  private fun getFallback(): Fallback {
+    fallback?.let {
+      return it
+    }
+
+    val layoutNodeClass = LayoutNode::class.java
+    val getChildren = tryResolve(layoutNodeClass, "getChildren\$ui_release")
+    val getOuterCoordinator = tryResolve(layoutNodeClass, "getOuterCoordinator\$ui_release")
+
+    return Fallback(getChildren, getOuterCoordinator).also { fallback = it }
+  }
+}
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
index 801c8b6e12b..e043b035668 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
@@ -44,7 +44,6 @@ import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.GenericViewHiera
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.ImageViewHierarchyNode
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.TextViewHierarchyNode
 import java.io.File
-import java.lang.reflect.InvocationTargetException
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -183,7 +182,7 @@ class ComposeMaskingOptionsTest {
     val node = mock<LayoutNode>()
     whenever(node.semanticsConfiguration).thenThrow(RuntimeException("Compose Runtime Error"))
 
-    assertThrows(InvocationTargetException::class.java) {
+    assertThrows(RuntimeException::class.java) {
       ComposeViewHierarchyNode.retrieveSemanticsConfiguration(node)
     }
   }
diff --git a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocator.kt b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocator.kt
index bf6a55110be..54deb774c53 100644
--- a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocator.kt
+++ b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocator.kt
@@ -44,68 +44,56 @@ public class ComposeGestureTargetLocator(private val logger: ILogger) : GestureT
 
     val rootLayoutNode = root.root
 
-    val queue: Queue<LayoutNode> = LinkedList()
-    queue.add(rootLayoutNode)
+    // Pair<Node, ParentTag>
+    val queue: Queue<Pair<LayoutNode, String?>> = LinkedList()
+    queue.add(Pair(rootLayoutNode, null))
 
-    // the final tag to return
+    // the final tag to return, only relevant for clicks
+    // as for scrolls, we return the first matching element
     var targetTag: String? = null
 
-    // the last known tag when iterating the node tree
-    var lastKnownTag: String? = null
     while (!queue.isEmpty()) {
-      val node = queue.poll() ?: continue
+      val (node, parentTag) = queue.poll() ?: continue
       if (node.isPlaced && layoutNodeBoundsContain(rootLayoutNode, node, x, y)) {
-        var isClickable = false
-        var isScrollable = false
-
-        val modifiers = node.getModifierInfo()
-        for (index in modifiers.indices) {
-          val modifierInfo = modifiers[index]
-          val tag = composeHelper!!.extractTag(modifierInfo.modifier)
-          if (tag != null) {
-            lastKnownTag = tag
-          }
-
-          if (modifierInfo.modifier is SemanticsModifier) {
-            val semanticsModifierCore = modifierInfo.modifier as SemanticsModifier
-            val semanticsConfiguration = semanticsModifierCore.semanticsConfiguration
-
-            for (item in semanticsConfiguration) {
-              val key: String = item.key.name
-              if ("ScrollBy" == key) {
-                isScrollable = true
-              } else if ("OnClick" == key) {
-                isClickable = true
+        val tag = extractTag(composeHelper!!, node) ?: parentTag
+        if (tag != null) {
+          val modifiers = node.getModifierInfo()
+          for (index in modifiers.indices) {
+            val modifierInfo = modifiers[index]
+            if (modifierInfo.modifier is SemanticsModifier) {
+              val semanticsModifierCore = modifierInfo.modifier as SemanticsModifier
+              val semanticsConfiguration = semanticsModifierCore.semanticsConfiguration
+
+              for (item in semanticsConfiguration) {
+                val key: String = item.key.name
+                if (targetType == UiElement.Type.SCROLLABLE && "ScrollBy" == key) {
+                  return UiElement(null, null, null, tag, ORIGIN)
+                } else if (targetType == UiElement.Type.CLICKABLE && "OnClick" == key) {
+                  targetTag = tag
+                }
+              }
+            } else {
+              // Jetpack Compose 1.5+: uses Node modifiers elements for clicks/scrolls
+              val modifier = modifierInfo.modifier
+              val type = modifier.javaClass.name
+              if (
+                targetType == UiElement.Type.CLICKABLE &&
+                  ("androidx.compose.foundation.ClickableElement" == type ||
+                    "androidx.compose.foundation.CombinedClickableElement" == type)
+              ) {
+                targetTag = tag
+              } else if (
+                targetType == UiElement.Type.SCROLLABLE &&
+                  ("androidx.compose.foundation.ScrollingLayoutElement" == type ||
+                    "androidx.compose.foundation.ScrollingContainerElement" == type)
+              ) {
+                return UiElement(null, null, null, tag, ORIGIN)
               }
-            }
-          } else {
-            val modifier = modifierInfo.modifier
-            // Newer Jetpack Compose 1.5 uses Node modifiers for clicks/scrolls
-            val type = modifier.javaClass.name
-            if (
-              "androidx.compose.foundation.ClickableElement" == type ||
-                "androidx.compose.foundation.CombinedClickableElement" == type
-            ) {
-              isClickable = true
-            } else if (
-              "androidx.compose.foundation.ScrollingLayoutElement" == type ||
-                "androidx.compose.foundation.ScrollingContainerElement" == type
-            ) {
-              isScrollable = true
             }
           }
         }
-
-        if (isClickable && targetType == UiElement.Type.CLICKABLE) {
-          targetTag = lastKnownTag
-        }
-        if (isScrollable && targetType == UiElement.Type.SCROLLABLE) {
-          targetTag = lastKnownTag
-          // skip any children for scrollable targets
-          break
-        }
+        queue.addAll(node.zSortedChildren.asMutableList().map { Pair(it, tag) })
       }
-      queue.addAll(node.zSortedChildren.asMutableList())
     }
 
     return if (targetTag == null) {
@@ -125,6 +113,18 @@ public class ComposeGestureTargetLocator(private val logger: ILogger) : GestureT
     return bounds.contains(Offset(x, y))
   }
 
+  private fun extractTag(composeHelper: SentryComposeHelper, node: LayoutNode): String? {
+    val modifiers = node.getModifierInfo()
+    for (index in modifiers.indices) {
+      val modifierInfo = modifiers[index]
+      val tag = composeHelper.extractTag(modifierInfo.modifier)
+      if (tag != null) {
+        return tag
+      }
+    }
+    return null
+  }
+
   public companion object {
     private const val ORIGIN = "jetpack_compose"
   }
diff --git a/sentry-compose/src/androidUnitTest/kotlin/androidx/compose/foundation/GestureModifierStubs.kt b/sentry-compose/src/androidUnitTest/kotlin/androidx/compose/foundation/GestureModifierStubs.kt
new file mode 100644
index 00000000000..43b3e53bc67
--- /dev/null
+++ b/sentry-compose/src/androidUnitTest/kotlin/androidx/compose/foundation/GestureModifierStubs.kt
@@ -0,0 +1,15 @@
+package androidx.compose.foundation
+
+import androidx.compose.ui.Modifier
+
+/**
+ * Stub classes used by [io.sentry.compose.gestures.ComposeGestureTargetLocatorTest] so that Mockito
+ * mocks of these classes return the correct [Class.getName] values at runtime.
+ */
+internal open class ClickableElement : Modifier.Element
+
+internal open class CombinedClickableElement : Modifier.Element
+
+internal open class ScrollingLayoutElement : Modifier.Element
+
+internal open class ScrollingContainerElement : Modifier.Element
diff --git a/sentry-compose/src/androidUnitTest/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocatorTest.kt b/sentry-compose/src/androidUnitTest/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocatorTest.kt
new file mode 100644
index 00000000000..8efdf3ebe30
--- /dev/null
+++ b/sentry-compose/src/androidUnitTest/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocatorTest.kt
@@ -0,0 +1,703 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
+package io.sentry.compose.gestures
+
+import androidx.compose.runtime.collection.mutableVectorOf
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.layout.AlignmentLine
+import androidx.compose.ui.layout.LayoutCoordinates
+import androidx.compose.ui.layout.ModifierInfo
+import androidx.compose.ui.node.LayoutNode
+import androidx.compose.ui.node.Owner
+import androidx.compose.ui.semantics.SemanticsConfiguration
+import androidx.compose.ui.semantics.SemanticsModifier
+import androidx.compose.ui.semantics.SemanticsPropertyKey
+import androidx.compose.ui.unit.IntSize
+import io.sentry.NoOpLogger
+import io.sentry.internal.gestures.UiElement
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Test
+import org.mockito.Mockito
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+class ComposeGestureTargetLocatorTest {
+
+  private val locator = ComposeGestureTargetLocator(NoOpLogger.getInstance())
+
+  /**
+   * Maps each child [LayoutCoordinates] to its bounding rect. Used by [FakeRootCoordinates] to
+   * return correct bounds when [LayoutCoordinates.localBoundingBoxOf] is called.
+   */
+  private val coordsBounds = mutableMapOf<LayoutCoordinates, Rect>()
+
+  private lateinit var rootCoordinates: LayoutCoordinates
+
+  @Before
+  fun setUp() {
+    coordsBounds.clear()
+    rootCoordinates = FakeRootCoordinates(1000, 1000, coordsBounds)
+    coordsBounds[rootCoordinates] = Rect(0f, 0f, 1000f, 1000f)
+  }
+
+  @Test
+  fun `returns null for non-Owner root`() {
+    val result = locator.locate("not an owner", 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNull(result)
+  }
+
+  @Test
+  fun `returns null for null root`() {
+    val result = locator.locate(null, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNull(result)
+  }
+
+  @Test
+  fun `returns null when no clickable elements`() {
+    val root = mockLayoutNode(isPlaced = true, tag = "root", width = 100, height = 100)
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNull(result)
+  }
+
+  @Test
+  fun `detects clickable via SemanticsModifier OnClick`() {
+    val clickableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "btn",
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("OnClick"),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(clickableChild),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNotNull(result)
+    assertEquals("btn", result!!.tag)
+    assertEquals("jetpack_compose", result.origin)
+  }
+
+  @Test
+  fun `detects scrollable via SemanticsModifier ScrollBy`() {
+    val scrollableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "list",
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("ScrollBy"),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(scrollableChild),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.SCROLLABLE)
+    assertNotNull(result)
+    assertEquals("list", result!!.tag)
+  }
+
+  @Test
+  fun `detects clickable via ClickableElement modifier`() {
+    val clickableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "btn",
+        width = 50,
+        height = 50,
+        nodeModifierClassName = "androidx.compose.foundation.ClickableElement",
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(clickableChild),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNotNull(result)
+    assertEquals("btn", result!!.tag)
+  }
+
+  @Test
+  fun `detects clickable via CombinedClickableElement modifier`() {
+    val clickableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "btn",
+        width = 50,
+        height = 50,
+        nodeModifierClassName = "androidx.compose.foundation.CombinedClickableElement",
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(clickableChild),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNotNull(result)
+    assertEquals("btn", result!!.tag)
+  }
+
+  @Test
+  fun `detects scrollable via ScrollingLayoutElement modifier`() {
+    val scrollableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "scroll",
+        width = 50,
+        height = 50,
+        nodeModifierClassName = "androidx.compose.foundation.ScrollingLayoutElement",
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(scrollableChild),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.SCROLLABLE)
+    assertNotNull(result)
+    assertEquals("scroll", result!!.tag)
+  }
+
+  @Test
+  fun `detects scrollable via ScrollingContainerElement modifier`() {
+    val scrollableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "scroll",
+        width = 50,
+        height = 50,
+        nodeModifierClassName = "androidx.compose.foundation.ScrollingContainerElement",
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(scrollableChild),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.SCROLLABLE)
+    assertNotNull(result)
+    assertEquals("scroll", result!!.tag)
+  }
+
+  @Test
+  fun `ignores clickable when looking for scrollable`() {
+    val clickableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "btn",
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("OnClick"),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(clickableChild),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.SCROLLABLE)
+    assertNull(result)
+  }
+
+  @Test
+  fun `ignores scrollable when looking for clickable`() {
+    val scrollableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "list",
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("ScrollBy"),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(scrollableChild),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNull(result)
+  }
+
+  @Test
+  fun `skips unplaced nodes`() {
+    val unplacedClickable =
+      mockLayoutNode(
+        isPlaced = false,
+        tag = "btn",
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("OnClick"),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(unplacedClickable),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNull(result)
+  }
+
+  @Test
+  fun `skips nodes outside bounds`() {
+    val clickableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "btn",
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("OnClick"),
+        left = 200f,
+        top = 200f,
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 300,
+        height = 300,
+        children = listOf(clickableChild),
+      )
+    val owner = mockOwner(root)
+
+    // click at (5, 5) is outside the child bounds (200-250, 200-250)
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNull(result)
+  }
+
+  @Test
+  fun `child inherits parent tag`() {
+    val clickableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("OnClick"),
+      )
+    val taggedParent =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "parent_tag",
+        width = 100,
+        height = 100,
+        children = listOf(clickableChild),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 200,
+        height = 200,
+        children = listOf(taggedParent),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNotNull(result)
+    assertEquals("parent_tag", result!!.tag)
+  }
+
+  @Test
+  fun `returns deepest clickable for clicks`() {
+    val deepChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "deep_btn",
+        width = 20,
+        height = 20,
+        semanticsKeys = listOf("OnClick"),
+      )
+    val parentClickable =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "parent_btn",
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("OnClick"),
+        children = listOf(deepChild),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(parentClickable),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNotNull(result)
+    assertEquals("deep_btn", result!!.tag)
+  }
+
+  @Test
+  fun `returns first scrollable immediately`() {
+    val deepScrollable =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "deep_scroll",
+        width = 20,
+        height = 20,
+        semanticsKeys = listOf("ScrollBy"),
+      )
+    val parentScrollable =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "parent_scroll",
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("ScrollBy"),
+        children = listOf(deepScrollable),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(parentScrollable),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.SCROLLABLE)
+    assertNotNull(result)
+    assertEquals("parent_scroll", result!!.tag)
+  }
+
+  @Test
+  fun `returns null when node has no tag and no parent tag`() {
+    val clickableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 50,
+        height = 50,
+        semanticsKeys = listOf("OnClick"),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(clickableChild),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNull(result)
+  }
+
+  @Test
+  fun `finds tagged clickable nested under untagged containers`() {
+    // Tree: root(no tag) -> container(no tag) -> container(no tag) -> clickable(tag="deep_btn")
+    val clickableChild =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = "deep_btn",
+        width = 10,
+        height = 10,
+        semanticsKeys = listOf("OnClick"),
+      )
+    val innerContainer =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 30,
+        height = 30,
+        children = listOf(clickableChild),
+      )
+    val outerContainer =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 60,
+        height = 60,
+        children = listOf(innerContainer),
+      )
+    val root =
+      mockLayoutNode(
+        isPlaced = true,
+        tag = null,
+        width = 100,
+        height = 100,
+        children = listOf(outerContainer),
+      )
+    val owner = mockOwner(root)
+
+    val result = locator.locate(owner, 5f, 5f, UiElement.Type.CLICKABLE)
+    assertNotNull(result)
+    assertEquals("deep_btn", result!!.tag)
+  }
+
+  // -- helpers --
+
+  private fun mockOwner(rootNode: LayoutNode): Owner {
+    // Wire the root node's coordinates to the shared rootCoordinates
+    whenever(rootNode.coordinates).thenReturn(rootCoordinates)
+    val owner = mock<Owner>()
+    whenever(owner.root).thenReturn(rootNode)
+    return owner
+  }
+
+  private fun mockLayoutNode(
+    isPlaced: Boolean,
+    tag: String?,
+    width: Int,
+    height: Int,
+    children: List<LayoutNode> = emptyList(),
+    semanticsKeys: List<String> = emptyList(),
+    nodeModifierClassName: String? = null,
+    left: Float = 0f,
+    top: Float = 0f,
+  ): LayoutNode {
+    val node = Mockito.mock(LayoutNode::class.java)
+    whenever(node.isPlaced).thenReturn(isPlaced)
+
+    val modifierInfoList = mutableListOf<ModifierInfo>()
+
+    if (tag != null) {
+      val tagModifierInfo = mockTestTagModifierInfo(tag)
+      if (tagModifierInfo != null) {
+        modifierInfoList.add(tagModifierInfo)
+      } else {
+        modifierInfoList.add(mockSemanticsTagModifierInfo(tag))
+      }
+    }
+
+    if (semanticsKeys.isNotEmpty()) {
+      modifierInfoList.add(mockSemanticsKeysModifierInfo(semanticsKeys))
+    }
+
+    if (nodeModifierClassName != null) {
+      modifierInfoList.add(mockNodeModifierInfo(nodeModifierClassName))
+    }
+
+    whenever(node.getModifierInfo()).thenReturn(modifierInfoList)
+    whenever(node.zSortedChildren)
+      .thenReturn(mutableVectorOf<LayoutNode>().apply { addAll(children) })
+
+    val coordinates = FakeChildCoordinates(left, top, width.toFloat(), height.toFloat())
+    coordsBounds[coordinates] = Rect(left, top, left + width, top + height)
+    whenever(node.coordinates).thenReturn(coordinates)
+
+    return node
+  }
+
+  /**
+   * Fake root [LayoutCoordinates] that avoids Mockito issues with inline classes like [Offset].
+   * Implements [localBoundingBoxOf] by looking up child bounds in [coordsBounds], and
+   * [localToWindow] as an identity transform.
+   */
+  private class FakeRootCoordinates(
+    private val width: Int,
+    private val height: Int,
+    private val boundsMap: Map<LayoutCoordinates, Rect>,
+  ) : LayoutCoordinates {
+    override val size: IntSize
+      get() = IntSize(width, height)
+
+    override val isAttached: Boolean
+      get() = true
+
+    override val parentLayoutCoordinates: LayoutCoordinates?
+      get() = null
+
+    override val parentCoordinates: LayoutCoordinates?
+      get() = null
+
+    override val providedAlignmentLines: Set<AlignmentLine>
+      get() = emptySet()
+
+    override fun get(alignmentLine: AlignmentLine): Int = AlignmentLine.Unspecified
+
+    override fun windowToLocal(relativeToWindow: Offset): Offset = relativeToWindow
+
+    override fun localToWindow(relativeToLocal: Offset): Offset = relativeToLocal
+
+    override fun localToRoot(relativeToLocal: Offset): Offset = relativeToLocal
+
+    override fun localPositionOf(
+      sourceCoordinates: LayoutCoordinates,
+      relativeToSource: Offset,
+    ): Offset = relativeToSource
+
+    override fun localBoundingBoxOf(
+      sourceCoordinates: LayoutCoordinates,
+      clipBounds: Boolean,
+    ): Rect = boundsMap[sourceCoordinates] ?: Rect.Zero
+
+    @Deprecated("Deprecated in interface")
+    override fun localToScreen(relativeToLocal: Offset): Offset = relativeToLocal
+
+    @Deprecated("Deprecated in interface")
+    override fun screenToLocal(relativeToScreen: Offset): Offset = relativeToScreen
+  }
+
+  /**
+   * Minimal fake [LayoutCoordinates] for child nodes. The actual bounds are resolved via
+   * [FakeRootCoordinates.localBoundingBoxOf], so this only needs identity implementations.
+   */
+  private class FakeChildCoordinates(
+    private val left: Float,
+    private val top: Float,
+    private val width: Float,
+    private val height: Float,
+  ) : LayoutCoordinates {
+    override val size: IntSize
+      get() = IntSize(width.toInt(), height.toInt())
+
+    override val isAttached: Boolean
+      get() = true
+
+    override val parentLayoutCoordinates: LayoutCoordinates?
+      get() = null
+
+    override val parentCoordinates: LayoutCoordinates?
+      get() = null
+
+    override val providedAlignmentLines: Set<AlignmentLine>
+      get() = emptySet()
+
+    override fun get(alignmentLine: AlignmentLine): Int = AlignmentLine.Unspecified
+
+    override fun windowToLocal(relativeToWindow: Offset): Offset = relativeToWindow
+
+    override fun localToWindow(relativeToLocal: Offset): Offset = relativeToLocal
+
+    override fun localToRoot(relativeToLocal: Offset): Offset = relativeToLocal
+
+    override fun localPositionOf(
+      sourceCoordinates: LayoutCoordinates,
+      relativeToSource: Offset,
+    ): Offset = relativeToSource
+
+    override fun localBoundingBoxOf(
+      sourceCoordinates: LayoutCoordinates,
+      clipBounds: Boolean,
+    ): Rect = Rect(left, top, left + width, top + height)
+
+    @Deprecated("Deprecated in interface")
+    override fun localToScreen(relativeToLocal: Offset): Offset = relativeToLocal
+
+    @Deprecated("Deprecated in interface")
+    override fun screenToLocal(relativeToScreen: Offset): Offset = relativeToScreen
+  }
+
+  companion object {
+    private fun mockTestTagModifierInfo(tag: String): ModifierInfo? {
+      return try {
+        val clazz = Class.forName("androidx.compose.ui.platform.TestTagElement")
+        val constructor = clazz.declaredConstructors.firstOrNull() ?: return null
+        constructor.isAccessible = true
+        val instance = constructor.newInstance(tag) as Modifier
+        val modifierInfo = Mockito.mock(ModifierInfo::class.java)
+        whenever(modifierInfo.modifier).thenReturn(instance)
+        modifierInfo
+      } catch (_: Throwable) {
+        null
+      }
+    }
+
+    private fun mockSemanticsTagModifierInfo(tag: String): ModifierInfo {
+      val modifierInfo = Mockito.mock(ModifierInfo::class.java)
+      whenever(modifierInfo.modifier)
+        .thenReturn(
+          object : SemanticsModifier {
+            override val semanticsConfiguration: SemanticsConfiguration
+              get() {
+                val config = SemanticsConfiguration()
+                config.set(SemanticsPropertyKey("TestTag") { s: String?, _: String? -> s }, tag)
+                return config
+              }
+          }
+        )
+      return modifierInfo
+    }
+
+    private fun mockSemanticsKeysModifierInfo(keys: List<String>): ModifierInfo {
+      val modifierInfo = Mockito.mock(ModifierInfo::class.java)
+      whenever(modifierInfo.modifier)
+        .thenReturn(
+          object : SemanticsModifier {
+            override val semanticsConfiguration: SemanticsConfiguration
+              get() {
+                val config = SemanticsConfiguration()
+                for (key in keys) {
+                  config.set(SemanticsPropertyKey<Unit>(key) { _, _ -> }, Unit)
+                }
+                return config
+              }
+          }
+        )
+      return modifierInfo
+    }
+
+    private fun mockNodeModifierInfo(className: String): ModifierInfo {
+      val modifierWithClassName =
+        Mockito.mock(
+          try {
+            Class.forName(className)
+          } catch (_: ClassNotFoundException) {
+            Modifier::class.java
+          }
+        ) as Modifier
+      val modifierInfo = Mockito.mock(ModifierInfo::class.java)
+      whenever(modifierInfo.modifier).thenReturn(modifierWithClassName)
+      return modifierInfo
+    }
+  }
+}

From 28b6988cfc57f1857fedf2e65141f76b5b5ce557 Mon Sep 17 00:00:00 2001
From: Antonis Lilis <antonis.lilis@gmail.com>
Date: Tue, 17 Mar 2026 14:34:34 +0100
Subject: [PATCH 059/391] feat(feedback): implement shake gesture detection
 (#5150)

* feat(feedback): implement shake gesture detection for user feedback form

Adds SentryShakeDetector (accelerometer-based) and ShakeDetectionIntegration
that shows the feedback dialog when a shake is detected. Controlled by
SentryFeedbackOptions.useShakeGesture (default false).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): improve shake detection robustness and add tests

- Add volatile/AtomicLong for thread-safe cross-thread field access
- Use SystemClock.elapsedRealtime() instead of System.currentTimeMillis()
- Use SENSOR_DELAY_NORMAL for better battery efficiency
- Add multi-shake counting (2+ threshold crossings within 1.5s window)
- Handle deferred init for already-resumed activities
- Wrap showDialog() in try-catch to prevent app crashes
- Improve activity transition handling in onActivityPaused
- Mark SentryShakeDetector as @ApiStatus.Internal
- Add unit tests for SentryShakeDetector and ShakeDetectionIntegration

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): prevent stacking multiple feedback dialogs on repeated shakes

Track dialog visibility with an isDialogShowing flag that is set before
showing and cleared via the onFormClose callback when the dialog is
dismissed. Double-checked on both sensor and UI threads to avoid races.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): restore original onFormClose to prevent callback chain growth

Save the user's original onFormClose once during register() and restore
it after each dialog dismiss, instead of wrapping it with a new lambda
each time.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): reset isDialogShowing on activity pause to prevent stuck flag

If showDialog silently fails (e.g. activity destroyed between post and
execution), isDialogShowing would stay true forever, permanently
disabling shake-to-feedback. Reset it in onActivityPaused since the
dialog cannot outlive its host activity.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): move isDialogShowing reset from onActivityPaused to onActivityDestroyed

AlertDialog survives pause/resume cycles (e.g. screen off/on), so
resetting isDialogShowing in onActivityPaused allowed duplicate dialogs.
Move the reset to onActivityDestroyed where the dialog truly cannot
survive.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): scope dialog flag to hosting activity and restore callback on error

- Only reset isDialogShowing in onActivityDestroyed when it's the
  activity that hosts the dialog, not any unrelated activity.
- Restore originalOnFormClose in the catch block when showDialog throws.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Optimise comparison

Co-authored-by: LucasZF <lucas-zimerman1@hotmail.com>

* ref(feedback): address review feedback from lucas-zimerman

- Rename ShakeDetectionIntegration to FeedbackShakeIntegration to
  clarify its purpose is feedback-specific (#1)
- Avoid Math.sqrt by comparing squared gForce values (#3)
- Null out listener before unregistering sensor to prevent in-flight
  callbacks during stop (#4)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): capture onFormClose at shake time instead of registration

Capture the current onFormClose callback just before showing the dialog
rather than caching it during register(). This ensures callbacks set by
the user after SDK init are preserved across shake-triggered dialogs.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Reverse sample changes

* fix(feedback): restore onFormClose in onActivityDestroyed fallback path

When the dialog's host activity is destroyed and onDismiss doesn't fire,
onActivityDestroyed now restores the previous onFormClose callback on
global options, preventing a stale wrapper from affecting subsequent
non-shake feedback dialogs.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): make previousOnFormClose volatile for thread safety

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): always restore onFormClose in onActivityDestroyed even when null

The previous null check on previousOnFormClose skipped restoration when
no user callback was set, leaving a stale wrapper in global options.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Update changelog

* ref(feedback): address review feedback for shake gesture detection

- Reuse single SentryShakeDetector instance across activity transitions
  instead of re-creating on every resume (reduces allocations)
- Memoize SensorManager and Sensor lookups to avoid repeated binder calls
- Use getDefaultSensor(TYPE_ACCELEROMETER, false) to avoid wakeup sensor
- Deliver sensor events on a background HandlerThread instead of main thread
- Use SentryUserFeedbackDialog.Builder directly with tracked activity
  instead of going through showDialog/CurrentActivityHolder
- Merge dialogActivity into currentActivity, use AppState.isInBackground()
  to gate against background shakes
- Fix integration count in SentryAndroidTest (19 -> 20)

Tested manually on Pixel 8 Pro by enabling useShakeGesture in the sample
app's SentryAndroid.init and verifying shake opens the feedback dialog.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Format code

* feat(feedback): add manifest meta-data support for useShakeGesture

Allow enabling shake gesture via AndroidManifest.xml:
<meta-data android:name="io.sentry.feedback.use-shake-gesture" android:value="true" />

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): preserve currentActivity in onActivityPaused when dialog is showing

onActivityPaused always fires before onActivityDestroyed. Without this
fix, currentActivity was set to null in onPause, making the cleanup
condition in onActivityDestroyed (activity == currentActivity) always
false. This left isDialogShowing permanently stuck as true, disabling
shake-to-feedback for the rest of the session.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): pass real logger to SentryShakeDetector on init

The detector was constructed with NoOpLogger and the logger field was
final, so all diagnostic messages (sensor unavailable warnings) were
silently swallowed. Now init(context, logger) updates the logger from
SentryOptions.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Format code

* fix(feedback): clear stale activity ref and reset shake state on stop

- Clear currentActivity in onActivityDestroyed to prevent holding a
  stale reference to a destroyed activity context
- Reset shakeCount and firstShakeTimestamp in stop() to prevent
  cross-session false triggers across pause/resume cycles

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): clean up dialog state when a different activity resumes

When a dialog is showing on Activity A and the user navigates to
Activity B (e.g. via notification), onActivityResumed(B) overwrites
currentActivity. Later onActivityDestroyed(A) can't match and cleanup
never runs, leaving isDialogShowing permanently stuck. Now we detect
this in onActivityResumed and clean up proactively.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): capture onFormClose as local variable in lambda

The onFormClose lambda was reading previousOnFormClose field at dismiss
time. If onActivityResumed or onActivityDestroyed already restored and
nulled the field, the lambda would overwrite onFormClose with null. Now
captured as a local variable at dialog creation time.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): restore onFormClose in close() when dialog is showing

When close() is called while a dialog is showing, lifecycle callbacks
are unregistered so onActivityDestroyed cleanup won't fire. Restore
previousOnFormClose and reset dialog state in close() to prevent
the callback from being permanently overwritten.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): check isFinishing/isDestroyed before showing dialog

Add proactive activity validity check inside the runOnUiThread lambda
to avoid hitting the catch block with a BadTokenException when the
activity becomes invalid between the shake callback and UI execution.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Format code

* Enable the feature on the demo app for easier testing

* Use a weak reference for activity

* Reuse sentry-shake handler thread

* Add close to the API

* fix(feedback): use instanceof check for SentryAndroidOptions cast

Follow the established defensive pattern used by all other Android
integrations instead of an unchecked cast that could throw
ClassCastException if a hybrid SDK passes a different options type.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: LucasZF <lucas-zimerman1@hotmail.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |   6 +
 .../api/sentry-android-core.api               |  26 +++
 .../core/AndroidOptionsInitializer.java       |   1 +
 .../core/FeedbackShakeIntegration.java        | 198 ++++++++++++++++++
 .../android/core/ManifestMetadataReader.java  |   5 +
 .../android/core/SentryShakeDetector.java     | 153 ++++++++++++++
 .../core/FeedbackShakeIntegrationTest.kt      | 106 ++++++++++
 .../core/ManifestMetadataReaderTest.kt        |  25 +++
 .../sentry/android/core/SentryAndroidTest.kt  |   3 +-
 .../android/core/SentryShakeDetectorTest.kt   | 165 +++++++++++++++
 .../src/main/AndroidManifest.xml              |   3 +
 sentry/api/sentry.api                         |   2 +
 .../java/io/sentry/SentryFeedbackOptions.java |  24 +++
 13 files changed, 716 insertions(+), 1 deletion(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 866a450519a..5bc9a21cf98 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+### Features
+
+- Show feedback form on device shake ([#5150](https://github.com/getsentry/sentry-java/pull/5150))
+  - Enable via `options.getFeedbackOptions().setUseShakeGesture(true)` or manifest meta-data `io.sentry.feedback.use-shake-gesture`
+  - Uses the device's accelerometer — no special permissions required
+
 ### Fixes
 
 - Support masking/unmasking and click/scroll detection for Jetpack Compose 1.10+ ([#5189](https://github.com/getsentry/sentry-java/pull/5189))
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 4e7e7b4c5c2..0d83082548f 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -269,6 +269,19 @@ public abstract class io/sentry/android/core/EnvelopeFileObserverIntegration : i
 	public final fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 
+public final class io/sentry/android/core/FeedbackShakeIntegration : android/app/Application$ActivityLifecycleCallbacks, io/sentry/Integration, java/io/Closeable {
+	public fun <init> (Landroid/app/Application;)V
+	public fun close ()V
+	public fun onActivityCreated (Landroid/app/Activity;Landroid/os/Bundle;)V
+	public fun onActivityDestroyed (Landroid/app/Activity;)V
+	public fun onActivityPaused (Landroid/app/Activity;)V
+	public fun onActivityResumed (Landroid/app/Activity;)V
+	public fun onActivitySaveInstanceState (Landroid/app/Activity;Landroid/os/Bundle;)V
+	public fun onActivityStarted (Landroid/app/Activity;)V
+	public fun onActivityStopped (Landroid/app/Activity;)V
+	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
+}
+
 public abstract interface class io/sentry/android/core/IDebugImagesLoader {
 	public abstract fun clearDebugImages ()V
 	public abstract fun loadDebugImages ()Ljava/util/List;
@@ -462,6 +475,19 @@ public final class io/sentry/android/core/SentryScreenshotOptions : io/sentry/Se
 	public fun trackCustomMasking ()V
 }
 
+public final class io/sentry/android/core/SentryShakeDetector : android/hardware/SensorEventListener {
+	public fun <init> (Lio/sentry/ILogger;)V
+	public fun close ()V
+	public fun onAccuracyChanged (Landroid/hardware/Sensor;I)V
+	public fun onSensorChanged (Landroid/hardware/SensorEvent;)V
+	public fun start (Landroid/content/Context;Lio/sentry/android/core/SentryShakeDetector$Listener;)V
+	public fun stop ()V
+}
+
+public abstract interface class io/sentry/android/core/SentryShakeDetector$Listener {
+	public abstract fun onShake ()V
+}
+
 public class io/sentry/android/core/SentryUserFeedbackButton : android/widget/Button {
 	public fun <init> (Landroid/content/Context;)V
 	public fun <init> (Landroid/content/Context;Landroid/util/AttributeSet;)V
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index f83960a3e6b..5f7fad69b5d 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -410,6 +410,7 @@ static void installDefaultIntegrations(
               (Application) context, buildInfoProvider, activityFramesTracker));
       options.addIntegration(new ActivityBreadcrumbsIntegration((Application) context));
       options.addIntegration(new UserInteractionIntegration((Application) context, loadClass));
+      options.addIntegration(new FeedbackShakeIntegration((Application) context));
       if (isFragmentAvailable) {
         options.addIntegration(new FragmentLifecycleIntegration((Application) context, true, true));
       }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
new file mode 100644
index 00000000000..b845b6ed8c4
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
@@ -0,0 +1,198 @@
+package io.sentry.android.core;
+
+import static io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+import io.sentry.IScopes;
+import io.sentry.Integration;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import io.sentry.util.Objects;
+import java.io.Closeable;
+import java.io.IOException;
+import java.lang.ref.WeakReference;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Detects shake gestures and shows the user feedback dialog when a shake is detected. Only active
+ * when {@link io.sentry.SentryFeedbackOptions#isUseShakeGesture()} returns {@code true}.
+ */
+public final class FeedbackShakeIntegration
+    implements Integration, Closeable, Application.ActivityLifecycleCallbacks {
+
+  private final @NotNull Application application;
+  private final @NotNull SentryShakeDetector shakeDetector;
+  private @Nullable SentryAndroidOptions options;
+  private volatile @Nullable WeakReference<Activity> currentActivityRef;
+  private volatile boolean isDialogShowing = false;
+  private volatile @Nullable Runnable previousOnFormClose;
+
+  public FeedbackShakeIntegration(final @NotNull Application application) {
+    this.application = Objects.requireNonNull(application, "Application is required");
+    this.shakeDetector = new SentryShakeDetector(io.sentry.NoOpLogger.getInstance());
+  }
+
+  @Override
+  public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions sentryOptions) {
+    this.options =
+        Objects.requireNonNull(
+            (sentryOptions instanceof SentryAndroidOptions)
+                ? (SentryAndroidOptions) sentryOptions
+                : null,
+            "SentryAndroidOptions is required");
+
+    if (!this.options.getFeedbackOptions().isUseShakeGesture()) {
+      return;
+    }
+
+    shakeDetector.init(application, options.getLogger());
+
+    addIntegrationToSdkVersion("FeedbackShake");
+    application.registerActivityLifecycleCallbacks(this);
+    options.getLogger().log(SentryLevel.DEBUG, "FeedbackShakeIntegration installed.");
+
+    // In case of a deferred init, hook into any already-resumed activity
+    final @Nullable Activity activity = CurrentActivityHolder.getInstance().getActivity();
+    if (activity != null) {
+      currentActivityRef = new WeakReference<>(activity);
+      startShakeDetection(activity);
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    application.unregisterActivityLifecycleCallbacks(this);
+    shakeDetector.close();
+    // Restore onFormClose if a dialog is still showing, since lifecycle callbacks
+    // are now unregistered and onActivityDestroyed cleanup won't fire.
+    if (isDialogShowing) {
+      isDialogShowing = false;
+      if (options != null) {
+        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
+      }
+      previousOnFormClose = null;
+    }
+    currentActivityRef = null;
+  }
+
+  @Override
+  public void onActivityResumed(final @NotNull Activity activity) {
+    // If a dialog is showing on a different activity (e.g. user navigated via notification),
+    // clean up since the dialog's host activity is going away and onActivityDestroyed
+    // won't match currentActivity anymore.
+    final @Nullable Activity current = currentActivityRef != null ? currentActivityRef.get() : null;
+    if (isDialogShowing && current != null && current != activity) {
+      isDialogShowing = false;
+      if (options != null) {
+        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
+      }
+      previousOnFormClose = null;
+    }
+    currentActivityRef = new WeakReference<>(activity);
+    startShakeDetection(activity);
+  }
+
+  @Override
+  public void onActivityPaused(final @NotNull Activity activity) {
+    // Only stop if this is the activity we're tracking. When transitioning between
+    // activities, B.onResume may fire before A.onPause — stopping unconditionally
+    // would kill shake detection for the new activity.
+    final @Nullable Activity current = currentActivityRef != null ? currentActivityRef.get() : null;
+    if (activity == current) {
+      stopShakeDetection();
+      // Keep currentActivityRef set when a dialog is showing so onActivityDestroyed
+      // can still match and clean up. Otherwise the cleanup condition
+      // (activity == current) would always be false since onPause fires
+      // before onDestroy.
+      if (!isDialogShowing) {
+        currentActivityRef = null;
+      }
+    }
+  }
+
+  @Override
+  public void onActivityCreated(
+      final @NotNull Activity activity, final @Nullable Bundle savedInstanceState) {}
+
+  @Override
+  public void onActivityStarted(final @NotNull Activity activity) {}
+
+  @Override
+  public void onActivityStopped(final @NotNull Activity activity) {}
+
+  @Override
+  public void onActivitySaveInstanceState(
+      final @NotNull Activity activity, final @NotNull Bundle outState) {}
+
+  @Override
+  public void onActivityDestroyed(final @NotNull Activity activity) {
+    // Only reset if this is the activity that hosts the dialog — the dialog cannot
+    // outlive its host activity being destroyed.
+    final @Nullable Activity current = currentActivityRef != null ? currentActivityRef.get() : null;
+    if (isDialogShowing && activity == current) {
+      isDialogShowing = false;
+      currentActivityRef = null;
+      if (options != null) {
+        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
+      }
+      previousOnFormClose = null;
+    }
+  }
+
+  private void startShakeDetection(final @NotNull Activity activity) {
+    if (options == null) {
+      return;
+    }
+    // Stop any existing detection (e.g. when transitioning between activities)
+    stopShakeDetection();
+    shakeDetector.start(
+        activity,
+        () -> {
+          final @Nullable WeakReference<Activity> ref = currentActivityRef;
+          final Activity active = ref != null ? ref.get() : null;
+          final Boolean inBackground = AppState.getInstance().isInBackground();
+          if (active != null
+              && options != null
+              && !isDialogShowing
+              && !Boolean.TRUE.equals(inBackground)) {
+            active.runOnUiThread(
+                () -> {
+                  if (isDialogShowing || active.isFinishing() || active.isDestroyed()) {
+                    return;
+                  }
+                  try {
+                    isDialogShowing = true;
+                    final Runnable captured = options.getFeedbackOptions().getOnFormClose();
+                    previousOnFormClose = captured;
+                    options
+                        .getFeedbackOptions()
+                        .setOnFormClose(
+                            () -> {
+                              isDialogShowing = false;
+                              options.getFeedbackOptions().setOnFormClose(captured);
+                              if (captured != null) {
+                                captured.run();
+                              }
+                              previousOnFormClose = null;
+                            });
+                    new SentryUserFeedbackDialog.Builder(active).create().show();
+                  } catch (Throwable e) {
+                    isDialogShowing = false;
+                    options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
+                    previousOnFormClose = null;
+                    options
+                        .getLogger()
+                        .log(SentryLevel.ERROR, "Failed to show feedback dialog on shake.", e);
+                  }
+                });
+          }
+        });
+  }
+
+  private void stopShakeDetection() {
+    shakeDetector.stop();
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 940fe8f4362..822d7fbbe08 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -167,6 +167,8 @@ final class ManifestMetadataReader {
 
   static final String FEEDBACK_SHOW_BRANDING = "io.sentry.feedback.show-branding";
 
+  static final String FEEDBACK_USE_SHAKE_GESTURE = "io.sentry.feedback.use-shake-gesture";
+
   static final String SPOTLIGHT_ENABLE = "io.sentry.spotlight.enable";
 
   static final String SPOTLIGHT_CONNECTION_URL = "io.sentry.spotlight.url";
@@ -661,6 +663,9 @@ static void applyMetadata(
                 metadata, logger, FEEDBACK_USE_SENTRY_USER, feedbackOptions.isUseSentryUser()));
         feedbackOptions.setShowBranding(
             readBool(metadata, logger, FEEDBACK_SHOW_BRANDING, feedbackOptions.isShowBranding()));
+        feedbackOptions.setUseShakeGesture(
+            readBool(
+                metadata, logger, FEEDBACK_USE_SHAKE_GESTURE, feedbackOptions.isUseShakeGesture()));
 
         options.setEnableSpotlight(
             readBool(metadata, logger, SPOTLIGHT_ENABLE, options.isEnableSpotlight()));
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java
new file mode 100644
index 00000000000..5b6f63309ff
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java
@@ -0,0 +1,153 @@
+package io.sentry.android.core;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.SystemClock;
+import io.sentry.ILogger;
+import io.sentry.SentryLevel;
+import java.util.concurrent.atomic.AtomicLong;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Detects shake gestures using the device's accelerometer.
+ *
+ * <p>The accelerometer sensor (TYPE_ACCELEROMETER) does NOT require any special permissions on
+ * Android. The BODY_SENSORS permission is only needed for heart rate and similar body sensors.
+ *
+ * <p>Requires at least {@link #SHAKE_COUNT_THRESHOLD} accelerometer readings above {@link
+ * #SHAKE_THRESHOLD_GRAVITY} within {@link #SHAKE_WINDOW_MS} to trigger a shake event.
+ *
+ * <p>Sensor events are delivered on a background {@link HandlerThread} to avoid polluting the main
+ * thread.
+ */
+@ApiStatus.Internal
+public final class SentryShakeDetector implements SensorEventListener {
+
+  private static final float SHAKE_THRESHOLD_GRAVITY = 2.7f;
+  private static final int SHAKE_WINDOW_MS = 1500;
+  private static final int SHAKE_COUNT_THRESHOLD = 2;
+  private static final int SHAKE_COOLDOWN_MS = 1000;
+
+  private @Nullable SensorManager sensorManager;
+  private @Nullable Sensor accelerometer;
+  private @Nullable HandlerThread handlerThread;
+  private @Nullable Handler handler;
+  private final @NotNull AtomicLong lastShakeTimestamp = new AtomicLong(0);
+  private volatile @Nullable Listener listener;
+  private @NotNull ILogger logger;
+
+  private int shakeCount = 0;
+  private long firstShakeTimestamp = 0;
+
+  public interface Listener {
+    void onShake();
+  }
+
+  public SentryShakeDetector(final @NotNull ILogger logger) {
+    this.logger = logger;
+  }
+
+  /**
+   * Initializes the sensor manager and accelerometer sensor. This is separated from start() so the
+   * values can be resolved once and reused across activity transitions.
+   */
+  void init(final @NotNull Context context, final @NotNull ILogger logger) {
+    this.logger = logger;
+    init(context);
+  }
+
+  private void init(final @NotNull Context context) {
+    if (sensorManager == null) {
+      sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
+    }
+    if (sensorManager != null && accelerometer == null) {
+      accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER, false);
+    }
+    if (accelerometer != null && handlerThread == null) {
+      handlerThread = new HandlerThread("sentry-shake");
+      handlerThread.start();
+      handler = new Handler(handlerThread.getLooper());
+    }
+  }
+
+  public void start(final @NotNull Context context, final @NotNull Listener shakeListener) {
+    this.listener = shakeListener;
+    init(context);
+    if (sensorManager == null) {
+      logger.log(SentryLevel.WARNING, "SensorManager is not available. Shake detection disabled.");
+      return;
+    }
+    if (accelerometer == null) {
+      logger.log(
+          SentryLevel.WARNING, "Accelerometer sensor not available. Shake detection disabled.");
+      return;
+    }
+    sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_NORMAL, handler);
+  }
+
+  public void stop() {
+    listener = null;
+    shakeCount = 0;
+    firstShakeTimestamp = 0;
+    if (sensorManager != null) {
+      sensorManager.unregisterListener(this);
+    }
+  }
+
+  /** Stops detection and releases the background thread. */
+  public void close() {
+    stop();
+    if (handlerThread != null) {
+      handlerThread.quitSafely();
+      handlerThread = null;
+      handler = null;
+    }
+  }
+
+  @Override
+  public void onSensorChanged(final @NotNull SensorEvent event) {
+    if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) {
+      return;
+    }
+    float gX = event.values[0] / SensorManager.GRAVITY_EARTH;
+    float gY = event.values[1] / SensorManager.GRAVITY_EARTH;
+    float gZ = event.values[2] / SensorManager.GRAVITY_EARTH;
+    double gForceSquared = gX * gX + gY * gY + gZ * gZ;
+    if (gForceSquared > SHAKE_THRESHOLD_GRAVITY * SHAKE_THRESHOLD_GRAVITY) {
+      long now = SystemClock.elapsedRealtime();
+
+      // Reset counter if outside the detection window
+      if (now - firstShakeTimestamp > SHAKE_WINDOW_MS) {
+        shakeCount = 0;
+        firstShakeTimestamp = now;
+      }
+
+      shakeCount++;
+
+      if (shakeCount >= SHAKE_COUNT_THRESHOLD) {
+        // Enforce cooldown so we don't fire repeatedly
+        long lastShake = lastShakeTimestamp.get();
+        if (now - lastShake > SHAKE_COOLDOWN_MS) {
+          lastShakeTimestamp.set(now);
+          shakeCount = 0;
+          final @Nullable Listener currentListener = listener;
+          if (currentListener != null) {
+            currentListener.onShake();
+          }
+        }
+      }
+    }
+  }
+
+  @Override
+  public void onAccuracyChanged(final @NotNull Sensor sensor, final int accuracy) {
+    // Not needed for shake detection.
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
new file mode 100644
index 00000000000..cb940686c30
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
@@ -0,0 +1,106 @@
+package io.sentry.android.core
+
+import android.app.Activity
+import android.app.Application
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.Scopes
+import io.sentry.SentryFeedbackOptions
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+@RunWith(AndroidJUnit4::class)
+class FeedbackShakeIntegrationTest {
+
+  private class Fixture {
+    val application = mock<Application>()
+    val scopes = mock<Scopes>()
+    val options = SentryAndroidOptions().apply { dsn = "https://key@sentry.io/proj" }
+    val activity = mock<Activity>()
+    val dialogHandler = mock<SentryFeedbackOptions.IDialogHandler>()
+
+    init {
+      options.feedbackOptions.setDialogHandler(dialogHandler)
+    }
+
+    fun getSut(useShakeGesture: Boolean = true): FeedbackShakeIntegration {
+      options.feedbackOptions.isUseShakeGesture = useShakeGesture
+      return FeedbackShakeIntegration(application)
+    }
+  }
+
+  private val fixture = Fixture()
+
+  @BeforeTest
+  fun setup() {
+    CurrentActivityHolder.getInstance().clearActivity()
+  }
+
+  @Test
+  fun `when useShakeGesture is enabled registers activity lifecycle callbacks`() {
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    verify(fixture.application).registerActivityLifecycleCallbacks(any())
+  }
+
+  @Test
+  fun `when useShakeGesture is disabled does not register activity lifecycle callbacks`() {
+    val sut = fixture.getSut(useShakeGesture = false)
+    sut.register(fixture.scopes, fixture.options)
+
+    verify(fixture.application, never()).registerActivityLifecycleCallbacks(any())
+  }
+
+  @Test
+  fun `close unregisters activity lifecycle callbacks`() {
+    val sut = fixture.getSut()
+    sut.register(fixture.scopes, fixture.options)
+
+    sut.close()
+
+    verify(fixture.application).unregisterActivityLifecycleCallbacks(any())
+  }
+
+  @Test
+  fun `hooks into already-resumed activity on deferred init`() {
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+    whenever(fixture.activity.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut()
+    sut.register(fixture.scopes, fixture.options)
+
+    // The integration should have attempted to start shake detection
+    // (it will fail gracefully because SensorManager is null in tests,
+    // but the important thing is it tried)
+  }
+
+  @Test
+  fun `does not crash when no activity is available on deferred init`() {
+    val sut = fixture.getSut()
+    sut.register(fixture.scopes, fixture.options)
+    // Should not throw
+  }
+
+  @Test
+  fun `onActivityPaused stops shake detection`() {
+    val sut = fixture.getSut()
+    sut.register(fixture.scopes, fixture.options)
+
+    whenever(fixture.activity.getSystemService(any())).thenReturn(null)
+    sut.onActivityResumed(fixture.activity)
+    sut.onActivityPaused(fixture.activity)
+    // Should not throw, shake detection stopped gracefully
+  }
+
+  @Test
+  fun `close without register does not crash`() {
+    val sut = fixture.getSut()
+    sut.close()
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index b9b7d40e48a..ba01a9ecf7a 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -1950,6 +1950,31 @@ class ManifestMetadataReaderTest {
     assertFalse(fixture.options.feedbackOptions.isShowBranding)
   }
 
+  @Test
+  fun `applyMetadata reads feedback use shake gesture and keep default value if not found`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertFalse(fixture.options.feedbackOptions.isUseShakeGesture)
+  }
+
+  @Test
+  fun `applyMetadata reads feedback use shake gesture to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.FEEDBACK_USE_SHAKE_GESTURE to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.feedbackOptions.isUseShakeGesture)
+  }
+
   @Test
   fun `applyMetadata reads screenshot strategy canvas to options`() {
     // Arrange
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
index c0010fa64e3..9c0f68c3f98 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
@@ -477,7 +477,7 @@ class SentryAndroidTest {
     fixture.initSut(context = mock<Application>()) { options ->
       optionsRef = options
       options.dsn = "https://key@sentry.io/123"
-      assertEquals(19, options.integrations.size)
+      assertEquals(20, options.integrations.size)
       options.integrations.removeAll {
         it is UncaughtExceptionHandlerIntegration ||
           it is ShutdownHookIntegration ||
@@ -490,6 +490,7 @@ class SentryAndroidTest {
           it is ActivityLifecycleIntegration ||
           it is ActivityBreadcrumbsIntegration ||
           it is UserInteractionIntegration ||
+          it is FeedbackShakeIntegration ||
           it is FragmentLifecycleIntegration ||
           it is SentryTimberIntegration ||
           it is AppComponentsBreadcrumbsIntegration ||
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt
new file mode 100644
index 00000000000..98441e48a8d
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt
@@ -0,0 +1,165 @@
+package io.sentry.android.core
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorManager
+import android.os.Handler
+import android.os.SystemClock
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.ILogger
+import kotlin.test.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.isA
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+@RunWith(AndroidJUnit4::class)
+class SentryShakeDetectorTest {
+
+  private class Fixture {
+    val logger = mock<ILogger>()
+    val context = mock<Context>()
+    val sensorManager = mock<SensorManager>()
+    val accelerometer = mock<Sensor>()
+    val listener = mock<SentryShakeDetector.Listener>()
+
+    init {
+      whenever(context.getSystemService(Context.SENSOR_SERVICE)).thenReturn(sensorManager)
+      whenever(sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER, false))
+        .thenReturn(accelerometer)
+    }
+
+    fun getSut(): SentryShakeDetector {
+      return SentryShakeDetector(logger)
+    }
+  }
+
+  private val fixture = Fixture()
+
+  @Test
+  fun `registers sensor listener on start`() {
+    val sut = fixture.getSut()
+    sut.start(fixture.context, fixture.listener)
+
+    verify(fixture.sensorManager)
+      .registerListener(
+        eq(sut),
+        eq(fixture.accelerometer),
+        eq(SensorManager.SENSOR_DELAY_NORMAL),
+        isA<Handler>(),
+      )
+  }
+
+  @Test
+  fun `unregisters sensor listener on stop`() {
+    val sut = fixture.getSut()
+    sut.start(fixture.context, fixture.listener)
+    sut.stop()
+
+    verify(fixture.sensorManager).unregisterListener(sut)
+  }
+
+  @Test
+  fun `does not crash when SensorManager is null`() {
+    whenever(fixture.context.getSystemService(Context.SENSOR_SERVICE)).thenReturn(null)
+
+    val sut = fixture.getSut()
+    sut.start(fixture.context, fixture.listener)
+
+    verify(fixture.sensorManager, never())
+      .registerListener(any(), any<Sensor>(), any<Int>(), any<Handler>())
+  }
+
+  @Test
+  fun `does not crash when accelerometer is null`() {
+    whenever(fixture.sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER, false))
+      .thenReturn(null)
+
+    val sut = fixture.getSut()
+    sut.start(fixture.context, fixture.listener)
+
+    verify(fixture.sensorManager, never())
+      .registerListener(any(), any<Sensor>(), any<Int>(), any<Handler>())
+  }
+
+  @Test
+  fun `triggers listener when shake is detected`() {
+    // Advance clock so cooldown check (now - 0 > 1000) passes
+    SystemClock.setCurrentTimeMillis(2000)
+
+    val sut = fixture.getSut()
+    sut.start(fixture.context, fixture.listener)
+
+    // Needs at least SHAKE_COUNT_THRESHOLD (2) readings above threshold
+    val event1 = createSensorEvent(floatArrayOf(30f, 0f, 0f))
+    sut.onSensorChanged(event1)
+    val event2 = createSensorEvent(floatArrayOf(30f, 0f, 0f))
+    sut.onSensorChanged(event2)
+
+    verify(fixture.listener).onShake()
+  }
+
+  @Test
+  fun `does not trigger listener on single shake`() {
+    val sut = fixture.getSut()
+    sut.start(fixture.context, fixture.listener)
+
+    // A single threshold crossing should not trigger
+    val event = createSensorEvent(floatArrayOf(30f, 0f, 0f))
+    sut.onSensorChanged(event)
+
+    verify(fixture.listener, never()).onShake()
+  }
+
+  @Test
+  fun `does not trigger listener below threshold`() {
+    val sut = fixture.getSut()
+    sut.start(fixture.context, fixture.listener)
+
+    // Gravity only (1G) - no shake
+    val event = createSensorEvent(floatArrayOf(0f, 0f, SensorManager.GRAVITY_EARTH))
+    sut.onSensorChanged(event)
+
+    verify(fixture.listener, never()).onShake()
+  }
+
+  @Test
+  fun `does not trigger listener for non-accelerometer events`() {
+    val sut = fixture.getSut()
+    sut.start(fixture.context, fixture.listener)
+
+    val event = createSensorEvent(floatArrayOf(30f, 0f, 0f), sensorType = Sensor.TYPE_GYROSCOPE)
+    sut.onSensorChanged(event)
+
+    verify(fixture.listener, never()).onShake()
+  }
+
+  @Test
+  fun `stop without start does not crash`() {
+    val sut = fixture.getSut()
+    sut.stop()
+  }
+
+  private fun createSensorEvent(
+    values: FloatArray,
+    sensorType: Int = Sensor.TYPE_ACCELEROMETER,
+  ): SensorEvent {
+    val sensor = mock<Sensor>()
+    whenever(sensor.type).thenReturn(sensorType)
+
+    val constructor = SensorEvent::class.java.getDeclaredConstructor(Int::class.javaPrimitiveType)
+    constructor.isAccessible = true
+    val event = constructor.newInstance(values.size)
+    values.copyInto(event.values)
+
+    val sensorField = SensorEvent::class.java.getField("sensor")
+    sensorField.set(event, sensor)
+
+    return event
+  }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index d73a3150f0a..548e5e8ac0d 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -271,5 +271,8 @@
     <meta-data
       android:name="io.sentry.anr.enable-fingerprinting"
       android:value="true" />
+    <meta-data
+      android:name="io.sentry.feedback.use-shake-gesture"
+      android:value="true" />
   </application>
 </manifest>
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 0b8171da631..5b8f973e756 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -3158,6 +3158,7 @@ public final class io/sentry/SentryFeedbackOptions {
 	public fun isShowEmail ()Z
 	public fun isShowName ()Z
 	public fun isUseSentryUser ()Z
+	public fun isUseShakeGesture ()Z
 	public fun setCancelButtonLabel (Ljava/lang/CharSequence;)V
 	public fun setDialogHandler (Lio/sentry/SentryFeedbackOptions$IDialogHandler;)V
 	public fun setEmailLabel (Ljava/lang/CharSequence;)V
@@ -3180,6 +3181,7 @@ public final class io/sentry/SentryFeedbackOptions {
 	public fun setSubmitButtonLabel (Ljava/lang/CharSequence;)V
 	public fun setSuccessMessageText (Ljava/lang/CharSequence;)V
 	public fun setUseSentryUser (Z)V
+	public fun setUseShakeGesture (Z)V
 	public fun toString ()Ljava/lang/String;
 }
 
diff --git a/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java b/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java
index 77e0741f8d6..2a0ead54234 100644
--- a/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java
@@ -35,6 +35,9 @@ public final class SentryFeedbackOptions {
   /** Displays the Sentry logo inside of the form. Defaults to true. */
   private boolean showBranding = true;
 
+  /** Shows the feedback form when a shake gesture is detected. Defaults to {@code false}. */
+  private boolean useShakeGesture = false;
+
   // Text Customization
   /** The title of the feedback form. Defaults to "Report a Bug". */
   private @NotNull CharSequence formTitle = "Report a Bug";
@@ -102,6 +105,7 @@ public SentryFeedbackOptions(final @NotNull SentryFeedbackOptions other) {
     this.showEmail = other.showEmail;
     this.useSentryUser = other.useSentryUser;
     this.showBranding = other.showBranding;
+    this.useShakeGesture = other.useShakeGesture;
     this.formTitle = other.formTitle;
     this.submitButtonLabel = other.submitButtonLabel;
     this.cancelButtonLabel = other.cancelButtonLabel;
@@ -234,6 +238,24 @@ public void setShowBranding(final boolean showBranding) {
     this.showBranding = showBranding;
   }
 
+  /**
+   * Shows the feedback form when a shake gesture is detected. Defaults to {@code false}.
+   *
+   * @return true if shake gesture triggers the feedback form
+   */
+  public boolean isUseShakeGesture() {
+    return useShakeGesture;
+  }
+
+  /**
+   * Sets whether the feedback form is shown when a shake gesture is detected.
+   *
+   * @param useShakeGesture true to enable shake gesture triggering
+   */
+  public void setUseShakeGesture(final boolean useShakeGesture) {
+    this.useShakeGesture = useShakeGesture;
+  }
+
   /**
    * The title of the feedback form. Defaults to "Report a Bug".
    *
@@ -547,6 +569,8 @@ public String toString() {
         + useSentryUser
         + ", showBranding="
         + showBranding
+        + ", useShakeGesture="
+        + useShakeGesture
         + ", formTitle='"
         + formTitle
         + '\''

From c40144aa5a4f99cf0d72048eb7e870dee8c7f0a4 Mon Sep 17 00:00:00 2001
From: romtsn <4999776+romtsn@users.noreply.github.com>
Date: Tue, 17 Mar 2026 17:14:37 +0000
Subject: [PATCH 060/391] release: 8.36.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5bc9a21cf98..5d303a3c1e6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.36.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 05e47bc6ade..c9900e412b3 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.9.0
 
 # Release information
-versionName=8.35.0
+versionName=8.36.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 2dfcf3a0392112e212648ffe19e4dd42927b3a48 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 20 Mar 2026 09:58:07 +0000
Subject: [PATCH 061/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.13.3 (#5215)

Co-authored-by: GitHub <noreply@github.com>
---
 .github/workflows/integration-tests-benchmarks.yml | 2 +-
 gradle/libs.versions.toml                          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 5796cc0e020..bbef5db31fa 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -106,7 +106,7 @@ jobs:
         run: ./gradlew :sentry-android-integration-tests:test-app-sentry:assembleRelease
 
       - name: Collect app metrics
-        uses: getsentry/action-app-sdk-overhead-metrics@v1
+        uses: getsentry/action-app-sdk-overhead-metrics@5f2d99b8e5a7b833386524924d24320501099a44
         with:
           config: sentry-android-integration-tests/metrics-test.yml
           sauce-user: ${{ secrets.SAUCE_USERNAME }}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index d659e43438c..7b53258a5a6 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -148,7 +148,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.2" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.3" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From d3458802ef3450cb992771ef0b700ca539814c8f Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Fri, 20 Mar 2026 11:44:09 +0100
Subject: [PATCH 062/391] chore(ci): Fix app overhead metrics action failing
 because of Appium version (#5216)

---
 .github/workflows/integration-tests-benchmarks.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index bbef5db31fa..24310f9ec81 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -106,7 +106,7 @@ jobs:
         run: ./gradlew :sentry-android-integration-tests:test-app-sentry:assembleRelease
 
       - name: Collect app metrics
-        uses: getsentry/action-app-sdk-overhead-metrics@5f2d99b8e5a7b833386524924d24320501099a44
+        uses: getsentry/action-app-sdk-overhead-metrics@ecce2e2718b6d97ad62220fca05627900b061ed5
         with:
           config: sentry-android-integration-tests/metrics-test.yml
           sauce-user: ${{ secrets.SAUCE_USERNAME }}

From 55aaf9b86d6887b277ff7ca70e3ccf1d2e143092 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Fri, 20 Mar 2026 12:03:11 +0100
Subject: [PATCH 063/391] feat(replay): add beforeErrorSampling callback to
 Session Replay (#5214)

* feat(replay): add `beforeErrorSampling` callback to Session Replay

Add a BeforeErrorSamplingCallback to SentryReplayOptions that lets
developers filter which errors trigger replay capture. The callback
runs before the onErrorSampleRate dice roll - returning false skips
captureReplay entirely.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* docs: add changelog entry for beforeErrorSampling callback

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* docs: use any{} in changelog example

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Apply suggestion from @romtsn

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  | 19 ++++
 sentry/api/sentry.api                         |  6 ++
 .../src/main/java/io/sentry/SentryClient.java | 20 +++-
 .../java/io/sentry/SentryReplayOptions.java   | 47 ++++++++++
 .../test/java/io/sentry/SentryClientTest.kt   | 94 +++++++++++++++++++
 5 files changed, 185 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5d303a3c1e6..57d640f385a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,24 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- Android: Add `beforeErrorSampling` callback to Session Replay ([#5214](https://github.com/getsentry/sentry-java/pull/5214))
+  - Allows filtering which errors trigger replay capture before the `onErrorSampleRate` is checked
+  - Returning `false` skips replay capture entirely for that error; returning `true` proceeds with the normal sample rate check
+  - Example usage:
+    ```java
+    SentryAndroid.init(context) { options ->
+        options.sessionReplay.beforeErrorSampling =
+            SentryReplayOptions.BeforeErrorSamplingCallback { event, hint ->
+                // Skip replay for handled exceptions
+                val hasUnhandled = event.exceptions?.any { it.mechanism?.isHandled == false } == true
+                hasUnhandled
+            }
+    }
+    ```
+
 ## 8.36.0
 
 ### Features
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 5b8f973e756..cb9078ac07b 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -3998,6 +3998,7 @@ public final class io/sentry/SentryReplayOptions : io/sentry/SentryMaskingOption
 	public fun <init> (ZLio/sentry/protocol/SdkVersion;)V
 	public fun addMaskViewClass (Ljava/lang/String;)V
 	public fun addUnmaskViewClass (Ljava/lang/String;)V
+	public fun getBeforeErrorSampling ()Lio/sentry/SentryReplayOptions$BeforeErrorSamplingCallback;
 	public fun getErrorReplayDuration ()J
 	public fun getFrameRate ()I
 	public fun getNetworkDetailAllowUrls ()Ljava/util/List;
@@ -4017,6 +4018,7 @@ public final class io/sentry/SentryReplayOptions : io/sentry/SentryMaskingOption
 	public fun isSessionReplayEnabled ()Z
 	public fun isSessionReplayForErrorsEnabled ()Z
 	public fun isTrackConfiguration ()Z
+	public fun setBeforeErrorSampling (Lio/sentry/SentryReplayOptions$BeforeErrorSamplingCallback;)V
 	public fun setDebug (Z)V
 	public fun setMaskAllImages (Z)V
 	public fun setMaskAllText (Z)V
@@ -4034,6 +4036,10 @@ public final class io/sentry/SentryReplayOptions : io/sentry/SentryMaskingOption
 	public fun trackCustomMasking ()V
 }
 
+public abstract interface class io/sentry/SentryReplayOptions$BeforeErrorSamplingCallback {
+	public abstract fun execute (Lio/sentry/SentryEvent;Lio/sentry/Hint;)Z
+}
+
 public final class io/sentry/SentryReplayOptions$SentryReplayQuality : java/lang/Enum {
 	public static final field HIGH Lio/sentry/SentryReplayOptions$SentryReplayQuality;
 	public static final field LOW Lio/sentry/SentryReplayOptions$SentryReplayQuality;
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index 26c70f365f5..b8178e35517 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -231,7 +231,25 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
     // an event from the past. If it's cached, but with ApplyScopeData, it comes from the outbox
     // folder and we still want to capture replay (e.g. a native captureException error)
     if (event != null && !isBackfillable && !isCached && (event.isErrored() || event.isCrashed())) {
-      options.getReplayController().captureReplay(event.isCrashed());
+      boolean shouldCaptureReplay = true;
+      final SentryReplayOptions.BeforeErrorSamplingCallback beforeErrorSampling =
+          options.getSessionReplay().getBeforeErrorSampling();
+      if (beforeErrorSampling != null) {
+        try {
+          shouldCaptureReplay = beforeErrorSampling.execute(event, hint);
+        } catch (Throwable e) {
+          options
+              .getLogger()
+              .log(
+                  SentryLevel.ERROR,
+                  "The beforeErrorSampling callback threw an exception. Proceeding with replay capture.",
+                  e);
+          shouldCaptureReplay = true;
+        }
+      }
+      if (shouldCaptureReplay) {
+        options.getReplayController().captureReplay(event.isCrashed());
+      }
     }
 
     try {
diff --git a/sentry/src/main/java/io/sentry/SentryReplayOptions.java b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
index 3c618bfee9d..d4e0fd257cd 100644
--- a/sentry/src/main/java/io/sentry/SentryReplayOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
@@ -17,6 +17,25 @@
 
 public final class SentryReplayOptions extends SentryMaskingOptions {
 
+  /**
+   * Callback that is called before the error sample rate is checked for session replay. If the
+   * callback returns {@code false}, the replay will not be captured for this error event, and the
+   * {@code onErrorSampleRate} will not be checked. If the callback returns {@code true}, the {@code
+   * onErrorSampleRate} will be checked as usual. This allows developers to filter which errors
+   * trigger replay capture.
+   */
+  public interface BeforeErrorSamplingCallback {
+    /**
+     * Determines whether replay capture should proceed for the given error event.
+     *
+     * @param event the error event that triggered the replay capture
+     * @param hint the hint associated with the event
+     * @return {@code true} if the error sample rate should be checked, {@code false} to skip replay
+     *     capture entirely
+     */
+    boolean execute(@NotNull SentryEvent event, @NotNull Hint hint);
+  }
+
   private static final String CUSTOM_MASKING_INTEGRATION_NAME = "ReplayCustomMasking";
   private volatile boolean customMaskingTracked = false;
 
@@ -172,6 +191,12 @@ public enum SentryReplayQuality {
    */
   private @NotNull List<String> networkResponseHeaders = DEFAULT_HEADERS;
 
+  /**
+   * A callback that is called before the error sample rate is checked for session replay. Can be
+   * used to filter which errors trigger replay capture.
+   */
+  private @Nullable BeforeErrorSamplingCallback beforeErrorSampling;
+
   public SentryReplayOptions(final boolean empty, final @Nullable SdkVersion sdkVersion) {
     if (!empty) {
       // Add default mask classes directly without setting usingCustomMasking flag
@@ -469,4 +494,26 @@ public void setNetworkResponseHeaders(final @NotNull List<String> networkRespons
     merged.addAll(additionalHeaders);
     return Collections.unmodifiableList(new ArrayList<>(merged));
   }
+
+  /**
+   * Gets the callback that is called before the error sample rate is checked for session replay.
+   *
+   * @return the callback, or {@code null} if not set
+   */
+  public @Nullable BeforeErrorSamplingCallback getBeforeErrorSampling() {
+    return beforeErrorSampling;
+  }
+
+  /**
+   * Sets the callback that is called before the error sample rate is checked for session replay.
+   * Returning {@code false} from the callback will skip replay capture for the error event entirely
+   * (the {@code onErrorSampleRate} will not be checked). Returning {@code true} will proceed with
+   * the normal error sample rate check.
+   *
+   * @param beforeErrorSampling the callback, or {@code null} to disable filtering
+   */
+  public void setBeforeErrorSampling(
+      final @Nullable BeforeErrorSamplingCallback beforeErrorSampling) {
+    this.beforeErrorSampling = beforeErrorSampling;
+  }
 }
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index e7c4ae84b99..11ff80fd573 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -3195,6 +3195,100 @@ class SentryClientTest {
     assertFalse(called)
   }
 
+  @Test
+  fun `beforeErrorSampling returning false skips captureReplay`() {
+    var called = false
+    fixture.sentryOptions.setReplayController(
+      object : ReplayController by NoOpReplayController.getInstance() {
+        override fun captureReplay(isTerminating: Boolean?) {
+          called = true
+        }
+      }
+    )
+    fixture.sentryOptions.sessionReplay.beforeErrorSampling =
+      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ -> false }
+    val sut = fixture.getSut()
+
+    sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) })
+    assertFalse(called)
+  }
+
+  @Test
+  fun `beforeErrorSampling returning true proceeds with captureReplay`() {
+    var called = false
+    fixture.sentryOptions.setReplayController(
+      object : ReplayController by NoOpReplayController.getInstance() {
+        override fun captureReplay(isTerminating: Boolean?) {
+          called = true
+        }
+      }
+    )
+    fixture.sentryOptions.sessionReplay.beforeErrorSampling =
+      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ -> true }
+    val sut = fixture.getSut()
+
+    sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) })
+    assertTrue(called)
+  }
+
+  @Test
+  fun `beforeErrorSampling not set proceeds with captureReplay`() {
+    var called = false
+    fixture.sentryOptions.setReplayController(
+      object : ReplayController by NoOpReplayController.getInstance() {
+        override fun captureReplay(isTerminating: Boolean?) {
+          called = true
+        }
+      }
+    )
+    val sut = fixture.getSut()
+
+    sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) })
+    assertTrue(called)
+  }
+
+  @Test
+  fun `beforeErrorSampling throwing exception proceeds with captureReplay`() {
+    var called = false
+    fixture.sentryOptions.setReplayController(
+      object : ReplayController by NoOpReplayController.getInstance() {
+        override fun captureReplay(isTerminating: Boolean?) {
+          called = true
+        }
+      }
+    )
+    fixture.sentryOptions.sessionReplay.beforeErrorSampling =
+      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ -> throw RuntimeException("test") }
+    val sut = fixture.getSut()
+
+    sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) })
+    assertTrue(called)
+  }
+
+  @Test
+  fun `beforeErrorSampling receives correct event and hint`() {
+    var receivedEvent: SentryEvent? = null
+    var receivedHint: Hint? = null
+    fixture.sentryOptions.setReplayController(
+      object : ReplayController by NoOpReplayController.getInstance() {
+        override fun captureReplay(isTerminating: Boolean?) {}
+      }
+    )
+    fixture.sentryOptions.sessionReplay.beforeErrorSampling =
+      SentryReplayOptions.BeforeErrorSamplingCallback { event, hint ->
+        receivedEvent = event
+        receivedHint = hint
+        true
+      }
+    val sut = fixture.getSut()
+
+    val event = SentryEvent().apply { exceptions = listOf(SentryException()) }
+    val hint = Hint()
+    sut.captureEvent(event, hint)
+    assertSame(event, receivedEvent)
+    assertSame(hint, receivedHint)
+  }
+
   @Test
   fun `captures replay for cached events with apply scope`() {
     var called = false

From e2dce0b7ae88cde49ff74fe2c23e77949c449815 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Mon, 23 Mar 2026 12:00:10 +0100
Subject: [PATCH 064/391] chore(pi): Add pi settings for local skills (#5222)

---
 .pi/settings.json | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 .pi/settings.json

diff --git a/.pi/settings.json b/.pi/settings.json
new file mode 100644
index 00000000000..e614d527837
--- /dev/null
+++ b/.pi/settings.json
@@ -0,0 +1,6 @@
+{
+  "skills": [
+    "../.claude/skills"
+  ],
+  "enableSkillCommands": true
+}

From e6377ecdf191f63819ce16486971ca4942938c30 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 25 Mar 2026 06:22:38 +0100
Subject: [PATCH 065/391] build(opentelemetry): Bump OpenTelemetry dependencies
 (#5225)

* build(opentelemetry): Bump OpenTelemetry dependencies

Update OpenTelemetry core, instrumentation, and semantic conventions\nversions in the shared version catalog.\n\nThis keeps sentry-java aligned with newer OTel releases used by the\nopentelemetry modules and samples.\n\nCo-Authored-By: Claude <noreply@anthropic.com>

* changelog

* docs(changelog): Clarify OpenTelemetry bump versions

Align the OpenTelemetry changelog entry with prior dependency bump style\nby listing each artifact and including previous versions for context.\n\nThis makes the upgrade scope easier to review and mirrors the detail\nlevel used in earlier OpenTelemetry changelog entries.\n\nCo-Authored-By: Claude <noreply@anthropic.com>

* ci(e2e): Enable Spring Boot 4 no-agent system tests

Enable the spring-boot-4 opentelemetry-noagent sample in backend
system-test matrix and spring-boot-4 workflow.

This turns the previously commented-out no-agent scenario into an
active CI check so regressions are caught automatically.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(opentelemetry): Use stable Attributes API in core tests

Replace test usage of sdk.internal.AttributesMap with public Attributes builders.\n\nThe OTel dependency bump removed the internal class, which broke\n:sentry-opentelemetry:sentry-opentelemetry-core:compileTestKotlin and\ntherefore the full build.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .github/workflows/spring-boot-4-matrix.yml    | 15 ++++++------
 .github/workflows/system-tests-backend.yml    |  6 ++---
 CHANGELOG.md                                  |  9 +++++++
 gradle/libs.versions.toml                     | 10 ++++----
 .../OpenTelemetryAttributesExtractorTest.kt   | 24 +++++++++++++++----
 .../OtelInternalSpanDetectionUtilTest.kt      | 21 +++++++++++++---
 .../kotlin/SpanDescriptionExtractorTest.kt    | 23 ++++++++++++++----
 7 files changed, 80 insertions(+), 28 deletions(-)

diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index c82113828cc..b436a7f31ed 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -132,14 +132,13 @@ jobs:
             --auto-init "false" \
             --build "true"
 
-# needs a fix in opentelemetry-spring-boot-starter
-#      - name: Run sentry-samples-spring-boot-4-opentelemetry-noagent
-#        run: |
-#          python3 test/system-test-runner.py test \
-#            --module "sentry-samples-spring-boot-4-opentelemetry-noagent" \
-#            --agent false \
-#            --auto-init "true" \
-#            --build "true"
+      - name: Run sentry-samples-spring-boot-4-opentelemetry-noagent
+        run: |
+          python3 test/system-test-runner.py test \
+            --module "sentry-samples-spring-boot-4-opentelemetry-noagent" \
+            --agent false \
+            --auto-init "true" \
+            --build "true"
 
       - name: Run sentry-samples-spring-7
         run: |
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 4f7929343cc..f57f81aaf84 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -72,9 +72,9 @@ jobs:
           - sample: "sentry-samples-spring-boot-4-webflux"
             agent: "false"
             agent-auto-init: "true"
-#          - sample: "sentry-samples-spring-boot-4-opentelemetry-noagent"
-#            agent: "false"
-#            agent-auto-init: "true"
+          - sample: "sentry-samples-spring-boot-4-opentelemetry-noagent"
+            agent: "false"
+            agent-auto-init: "true"
           - sample: "sentry-samples-spring-boot-4-opentelemetry"
             agent: "true"
             agent-auto-init: "true"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 57d640f385a..58d20127fbf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,15 @@
     }
     ```
 
+### Dependencies
+
+- Bump OpenTelemetry ([#5225](https://github.com/getsentry/sentry-java/pull/5225))
+  - `opentelemetry` to `1.60.1` (was `1.57.0`)
+  - `opentelemetry-instrumentation` to `2.26.0` (was `2.23.0`)
+  - `opentelemetry-instrumentation-alpha` to `2.26.0-alpha` (was `2.23.0-alpha`)
+  - `opentelemetry-semconv` to `1.40.0` (was `1.37.0`)
+  - `opentelemetry-semconv-alpha` to `1.40.0-alpha` (was `1.37.0-alpha`)
+
 ## 8.36.0
 
 ### Features
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 7b53258a5a6..60be4fd2c03 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -22,12 +22,12 @@ nopen = "1.0.1"
 # see https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-compatibility-and-versioning.html#kotlin-compatibility
 # see https://developer.android.com/jetpack/androidx/releases/compose-kotlin
 okhttp = "4.9.2"
-otel = "1.57.0"
-otelInstrumentation = "2.23.0"
-otelInstrumentationAlpha = "2.23.0-alpha"
+otel = "1.60.1"
+otelInstrumentation = "2.26.0"
+otelInstrumentationAlpha = "2.26.0-alpha"
 # check https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/dependencyManagement/build.gradle.kts#L49 for release version above to find a compatible version
-otelSemanticConventions = "1.37.0"
-otelSemanticConventionsAlpha = "1.37.0-alpha"
+otelSemanticConventions = "1.40.0"
+otelSemanticConventionsAlpha = "1.40.0-alpha"
 retrofit = "2.9.0"
 slf4j = "1.7.30"
 springboot2 = "2.7.18"
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OpenTelemetryAttributesExtractorTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OpenTelemetryAttributesExtractorTest.kt
index 5cc37d80f9c..6d37240f0b2 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OpenTelemetryAttributesExtractorTest.kt
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OpenTelemetryAttributesExtractorTest.kt
@@ -1,8 +1,7 @@
 package io.sentry.opentelemetry
 
 import io.opentelemetry.api.common.AttributeKey
-import io.opentelemetry.sdk.internal.AttributesMap
-import io.opentelemetry.sdk.trace.SpanLimits
+import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.sdk.trace.data.SpanData
 import io.opentelemetry.semconv.HttpAttributes
 import io.opentelemetry.semconv.ServerAttributes
@@ -22,12 +21,12 @@ import org.mockito.kotlin.whenever
 class OpenTelemetryAttributesExtractorTest {
   private class Fixture {
     val spanData = mock<SpanData>()
-    val attributes = AttributesMap.create(100, SpanLimits.getDefault().maxAttributeValueLength)
+    var attributes: Attributes = Attributes.empty()
     val options = SentryOptions.empty()
     val scope = Scope(options)
 
     init {
-      whenever(spanData.attributes).thenReturn(attributes)
+      whenever(spanData.attributes).thenAnswer { attributes }
     }
   }
 
@@ -346,7 +345,22 @@ class OpenTelemetryAttributesExtractorTest {
   }
 
   private fun givenAttributes(map: Map<AttributeKey<out Any>, Any>) {
-    map.forEach { k, v -> fixture.attributes.put(k, v) }
+    fixture.attributes = buildAttributes(map)
+  }
+
+  private fun buildAttributes(map: Map<AttributeKey<out Any>, Any>): Attributes {
+    val builder = Attributes.builder()
+    map.forEach { (key, value) -> putAttribute(builder, key, value) }
+    return builder.build()
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  private fun putAttribute(
+    builder: io.opentelemetry.api.common.AttributesBuilder,
+    key: AttributeKey<out Any>,
+    value: Any,
+  ) {
+    builder.put(key as AttributeKey<Any>, value)
   }
 
   private fun whenExtractingAttributes() {
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelInternalSpanDetectionUtilTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelInternalSpanDetectionUtilTest.kt
index bc453be6c1a..63a6c77c520 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelInternalSpanDetectionUtilTest.kt
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelInternalSpanDetectionUtilTest.kt
@@ -1,8 +1,8 @@
 package io.sentry.opentelemetry
 
 import io.opentelemetry.api.common.AttributeKey
+import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.trace.SpanKind
-import io.opentelemetry.sdk.internal.AttributesMap
 import io.opentelemetry.semconv.HttpAttributes
 import io.opentelemetry.semconv.ServerAttributes
 import io.opentelemetry.semconv.UrlAttributes
@@ -17,7 +17,7 @@ import org.mockito.kotlin.whenever
 class OtelInternalSpanDetectionUtilTest {
   private class Fixture {
     val scopes = mock<IScopes>()
-    val attributes = AttributesMap.create(100, 100)
+    var attributes: Attributes = Attributes.empty()
     val options = SentryOptions.empty()
     var spanKind: SpanKind = SpanKind.INTERNAL
 
@@ -152,7 +152,22 @@ class OtelInternalSpanDetectionUtilTest {
   }
 
   private fun givenAttributes(map: Map<AttributeKey<out Any>, Any>) {
-    map.forEach { k, v -> fixture.attributes.put(k, v) }
+    fixture.attributes = buildAttributes(map)
+  }
+
+  private fun buildAttributes(map: Map<AttributeKey<out Any>, Any>): Attributes {
+    val builder = Attributes.builder()
+    map.forEach { (key, value) -> putAttribute(builder, key, value) }
+    return builder.build()
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  private fun putAttribute(
+    builder: io.opentelemetry.api.common.AttributesBuilder,
+    key: AttributeKey<out Any>,
+    value: Any,
+  ) {
+    builder.put(key as AttributeKey<Any>, value)
   }
 
   private fun givenDsn(dsn: String) {
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SpanDescriptionExtractorTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SpanDescriptionExtractorTest.kt
index af04914e278..9c5a1a352df 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SpanDescriptionExtractorTest.kt
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SpanDescriptionExtractorTest.kt
@@ -1,11 +1,11 @@
 package io.sentry.opentelemetry
 
 import io.opentelemetry.api.common.AttributeKey
+import io.opentelemetry.api.common.Attributes
 import io.opentelemetry.api.trace.SpanContext
 import io.opentelemetry.api.trace.SpanKind
 import io.opentelemetry.api.trace.TraceFlags
 import io.opentelemetry.api.trace.TraceState
-import io.opentelemetry.sdk.internal.AttributesMap
 import io.opentelemetry.sdk.trace.data.SpanData
 import io.opentelemetry.semconv.HttpAttributes
 import io.opentelemetry.semconv.UrlAttributes
@@ -22,14 +22,14 @@ class SpanDescriptionExtractorTest {
   private class Fixture {
     val sentrySpan = mock<IOtelSpanWrapper>()
     val otelSpan = mock<SpanData>()
-    val attributes = AttributesMap.create(100, 100)
+    var attributes: Attributes = Attributes.empty()
     var parentSpanContext = SpanContext.getInvalid()
     var spanKind = SpanKind.INTERNAL
     var spanName: String? = null
     var spanDescription: String? = null
 
     fun setup() {
-      whenever(otelSpan.attributes).thenReturn(attributes)
+      whenever(otelSpan.attributes).thenAnswer { attributes }
       whenever(otelSpan.parentSpanContext).thenReturn(parentSpanContext)
       whenever(otelSpan.kind).thenReturn(spanKind)
       spanName?.let { whenever(otelSpan.name).thenReturn(it) }
@@ -271,7 +271,22 @@ class SpanDescriptionExtractorTest {
   }
 
   private fun givenAttributes(map: Map<AttributeKey<out Any>, Any>) {
-    map.forEach { k, v -> fixture.attributes.put(k, v) }
+    fixture.attributes = buildAttributes(map)
+  }
+
+  private fun buildAttributes(map: Map<AttributeKey<out Any>, Any>): Attributes {
+    val builder = Attributes.builder()
+    map.forEach { (key, value) -> putAttribute(builder, key, value) }
+    return builder.build()
+  }
+
+  @Suppress("UNCHECKED_CAST")
+  private fun putAttribute(
+    builder: io.opentelemetry.api.common.AttributesBuilder,
+    key: AttributeKey<out Any>,
+    value: Any,
+  ) {
+    builder.put(key as AttributeKey<Any>, value)
   }
 
   private fun whenExtractingSpanInfo(): OtelSpanInfo {

From 65250bf782fc5ff89fc439edd3654beb01398ee0 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 25 Mar 2026 06:22:57 +0100
Subject: [PATCH 066/391] chore(skills): Add .agents symlink for Claude skills
 (#5224)

Add a project-local .agents/skills symlink that points to .claude/skills so pi can discover repository skills without per-repo .pi/settings.json.\n\nCo-Authored-By: Claude <noreply@anthropic.com>
---
 .agents/skills | 1 +
 1 file changed, 1 insertion(+)
 create mode 120000 .agents/skills

diff --git a/.agents/skills b/.agents/skills
new file mode 120000
index 00000000000..454b8427cd7
--- /dev/null
+++ b/.agents/skills
@@ -0,0 +1 @@
+../.claude/skills
\ No newline at end of file

From 6839cb084560b75d78c3456af44c6caa2909a221 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 25 Mar 2026 06:23:33 +0100
Subject: [PATCH 067/391] chore(repo): Ignore .factorypath and local Claude
 worktrees (#5227)

---
 .gitignore | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index b8c2d7e9da2..f232c32db51 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,6 +13,7 @@ local.properties
 **/sentry-native-local
 target/
 .classpath
+.factorypath
 .project
 .settings/
 bin/
@@ -30,5 +31,6 @@ spy.log
 **/tomcat.8080/webapps/
 **/__pycache__
 
-# Local Claude Code settings that should not be committed
+# Local Claude Code settings/state that should not be committed
 .claude/settings.local.json
+.claude/worktrees/

From 4c09f527dae5df7b9f7a37e73785bff58dc919a5 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 25 Mar 2026 06:37:04 +0100
Subject: [PATCH 068/391] Add a /test skill to run singular tests or per module
 tests (#5111)

* Add a /test skill to run singular tests or per module tests

* fix(test): Correct Android task detection in test skill

Map modules ending in -android to testDebugUnitTest so Android library
modules like sentry-launchdarkly-android do not fall back to test.

Add AskUserQuestion to allowed-tools so interactive mode can execute the
decision prompts described in the skill under restricted tool settings.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .claude/skills/test/SKILL.md | 85 ++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 .claude/skills/test/SKILL.md

diff --git a/.claude/skills/test/SKILL.md b/.claude/skills/test/SKILL.md
new file mode 100644
index 00000000000..bdef12364f3
--- /dev/null
+++ b/.claude/skills/test/SKILL.md
@@ -0,0 +1,85 @@
+---
+name: test
+description: Run tests for a specific SDK module. Use when asked to "run tests", "test module", "run unit tests", "run system tests", "run e2e tests", or test a specific class. Auto-detects unit vs system tests. Supports interactive mode.
+allowed-tools: Bash, Read, Glob, AskUserQuestion
+argument-hint: [interactive] <module-name-or-file-path> [test-class-filter]
+---
+
+# Run Tests
+
+Run tests for a specific module. Auto-detects whether to run unit tests or system tests.
+
+## Step 0: Check for Interactive Mode
+
+If `$ARGUMENTS` starts with `interactive` (e.g., `/test interactive sentry ScopesTest`), enable interactive mode. Strip the `interactive` keyword from the arguments before proceeding.
+
+In interactive mode, use AskUserQuestion at decision points as described in the steps below.
+
+## Step 1: Parse the Argument
+
+The argument can be either:
+- A **file path** (e.g., `@sentry/src/test/java/io/sentry/ScopesTest.kt`)
+- A **module name** (e.g., `sentry-android-core`, `sentry-samples-spring-boot-4`)
+- A **module name + test filter** (e.g., `sentry ScopesTest`)
+
+Extract the module name and optional test class filter from the argument.
+
+**Interactive mode:** If the test filter is ambiguous (e.g., matches multiple test classes across modules), use AskUserQuestion to let the user pick which test class(es) to run.
+
+## Step 2: Detect Test Type
+
+| Signal | Test Type |
+|--------|-----------|
+| Path contains `sentry-samples/` | System test |
+| Module name starts with `sentry-samples-` | System test |
+| Everything else | Unit test |
+
+## Step 3a: Run Unit Tests
+
+Determine the Gradle test task:
+
+| Module Pattern | Test Task |
+|---------------|-----------|
+| `sentry-android-*` | `testDebugUnitTest` |
+| `sentry-compose*` | `testDebugUnitTest` |
+| `*-android` | `testDebugUnitTest` |
+| Everything else | `test` |
+
+**Interactive mode:** Before running, read the test class file and use AskUserQuestion to ask:
+- "Run all tests in this class, or a specific method?" — list the test method names as options.
+
+If the user picks a specific method, use `--tests="*ClassName.methodName"` as the filter.
+
+With a test class filter:
+```bash
+./gradlew ':<module>:<task>' --tests="*<filter>*" --info
+```
+
+Without a filter:
+```bash
+./gradlew ':<module>:<task>' --info
+```
+
+## Step 3b: Run System Tests
+
+System tests require the Python-based test runner which manages a mock Sentry server and sample app lifecycle.
+
+1. Ensure the Python venv exists:
+```bash
+test -d .venv || make setupPython
+```
+
+2. Extract the sample module name. For file paths like `sentry-samples/<sample-module>/src/...`, the sample module is the directory name (e.g., `sentry-samples-spring`).
+
+3. Run the system test:
+```bash
+.venv/bin/python test/system-test-runner.py test --module <sample-module>
+```
+
+This starts the mock Sentry server, starts the sample app (Spring Boot/Tomcat/CLI), runs tests via `./gradlew :sentry-samples:<sample-module>:systemTest`, and cleans up afterwards.
+
+## Step 4: Report Results
+
+Summarize the test outcome:
+- Total tests run, passed, failed, skipped
+- For failures: show the failing test name and the assertion/error message

From ae6907dfcbc235a4e31e51b47c9d41aa7c2fe878 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 25 Mar 2026 06:44:39 +0100
Subject: [PATCH 069/391] feat(core): Add configurable IScopesStorageFactory to
 SentryOptions (#5199)

* feat(core): Add configurable IScopesStorageFactory to SentryOptions

Allow users to provide a custom IScopesStorage factory via
SentryOptions.setScopesStorageFactory(). When set, the custom factory
takes precedence over the default auto-detection logic.

Fixes #5193

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* changelog

* ref(core): Have ScopesStorageFactory implement IScopesStorageFactory

Add LoadClass and ILogger parameters to IScopesStorageFactory.create()
so custom factories have access to class loading utilities.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Revert "ref(core): Have ScopesStorageFactory implement IScopesStorageFactory"

This reverts commit a0d77eb80af274e5fe6a7412bc3b6547f520c2f3.

* feat(core): Pass SentryOptions to IScopesStorageFactory.create()

SPI-discovered factory implementations are instantiated via ServiceLoader
with no-arg constructors, so they need access to options like logger and
DSN at creation time. Change the interface method signature to accept
SentryOptions as a parameter.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 sentry/api/sentry.api                         |  6 +++
 .../java/io/sentry/IScopesStorageFactory.java | 11 +++++
 sentry/src/main/java/io/sentry/Sentry.java    |  5 +-
 .../main/java/io/sentry/SentryOptions.java    | 23 ++++++++++
 .../test/java/io/sentry/SentryOptionsTest.kt  | 23 ++++++++++
 sentry/src/test/java/io/sentry/SentryTest.kt  | 46 +++++++++++++++++++
 7 files changed, 114 insertions(+), 1 deletion(-)
 create mode 100644 sentry/src/main/java/io/sentry/IScopesStorageFactory.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 58d20127fbf..cbc6651ce34 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Features
 
+- Add configurable `IScopesStorageFactory` to `SentryOptions` for providing a custom `IScopesStorage`, e.g. when the default `ThreadLocal`-backed storage is incompatible with non-pinning thread models ([#5199](https://github.com/getsentry/sentry-java/pull/5199))
 - Android: Add `beforeErrorSampling` callback to Session Replay ([#5214](https://github.com/getsentry/sentry-java/pull/5214))
   - Allows filtering which errors trigger replay capture before the `onErrorSampleRate` is checked
   - Returning `false` skips replay capture entirely for that error; returning `true` proceeds with the normal sample rate check
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index cb9078ac07b..1d8ff4d3e0d 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -1060,6 +1060,10 @@ public abstract interface class io/sentry/IScopesStorage {
 	public abstract fun set (Lio/sentry/IScopes;)Lio/sentry/ISentryLifecycleToken;
 }
 
+public abstract interface class io/sentry/IScopesStorageFactory {
+	public abstract fun create (Lio/sentry/SentryOptions;)Lio/sentry/IScopesStorage;
+}
+
 public abstract interface class io/sentry/ISentryClient {
 	public abstract fun captureBatchedLogEvents (Lio/sentry/SentryLogEvents;)V
 	public abstract fun captureBatchedMetricsEvents (Lio/sentry/SentryMetricsEvents;)V
@@ -3631,6 +3635,7 @@ public class io/sentry/SentryOptions {
 	public fun getReplayController ()Lio/sentry/ReplayController;
 	public fun getSampleRate ()Ljava/lang/Double;
 	public fun getScopeObservers ()Ljava/util/List;
+	public fun getScopesStorageFactory ()Lio/sentry/IScopesStorageFactory;
 	public fun getSdkVersion ()Lio/sentry/protocol/SdkVersion;
 	public fun getSentryClientName ()Ljava/lang/String;
 	public fun getSerializer ()Lio/sentry/ISerializer;
@@ -3783,6 +3788,7 @@ public class io/sentry/SentryOptions {
 	public fun setRelease (Ljava/lang/String;)V
 	public fun setReplayController (Lio/sentry/ReplayController;)V
 	public fun setSampleRate (Ljava/lang/Double;)V
+	public fun setScopesStorageFactory (Lio/sentry/IScopesStorageFactory;)V
 	public fun setSdkVersion (Lio/sentry/protocol/SdkVersion;)V
 	public fun setSendClientReports (Z)V
 	public fun setSendDefaultPii (Z)V
diff --git a/sentry/src/main/java/io/sentry/IScopesStorageFactory.java b/sentry/src/main/java/io/sentry/IScopesStorageFactory.java
new file mode 100644
index 00000000000..129d97a935a
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/IScopesStorageFactory.java
@@ -0,0 +1,11 @@
+package io.sentry;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/** Factory for creating custom {@link IScopesStorage} implementations. */
+@ApiStatus.Experimental
+public interface IScopesStorageFactory {
+  @NotNull
+  IScopesStorage create(@NotNull SentryOptions options);
+}
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index 63caf829fc9..fee19dc4d09 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -439,7 +439,10 @@ private static void initFatalLogger(final @NotNull SentryOptions options) {
 
   private static void initScopesStorage(SentryOptions options) {
     getScopesStorage().close();
-    if (SentryOpenTelemetryMode.OFF == options.getOpenTelemetryMode()) {
+    if (options.getScopesStorageFactory() != null) {
+      scopesStorage = options.getScopesStorageFactory().create(options);
+      scopesStorage.init();
+    } else if (SentryOpenTelemetryMode.OFF == options.getOpenTelemetryMode()) {
       scopesStorage = new DefaultScopesStorage();
     } else {
       scopesStorage = ScopesStorageFactory.create(new LoadClass(), NoOpLogger.getInstance());
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index a831a11ea8e..862bd708aa4 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -557,6 +557,8 @@ public class SentryOptions {
 
   private @NotNull ISpanFactory spanFactory = NoOpSpanFactory.getInstance();
 
+  private @Nullable IScopesStorageFactory scopesStorageFactory;
+
   /**
    * Profiling traces rate. 101 hz means 101 traces in 1 second. Defaults to 101 to avoid possible
    * lockstep sampling. More on
@@ -3557,6 +3559,27 @@ public void setSpanFactory(final @NotNull ISpanFactory spanFactory) {
     this.spanFactory = spanFactory;
   }
 
+  /**
+   * Returns the custom scopes storage factory, or null if auto-detection should be used.
+   *
+   * @return the custom scopes storage factory or null
+   */
+  @ApiStatus.Experimental
+  public @Nullable IScopesStorageFactory getScopesStorageFactory() {
+    return scopesStorageFactory;
+  }
+
+  /**
+   * Sets a custom factory for creating {@link IScopesStorage} implementations. When set, this
+   * factory takes precedence over the default auto-detection logic.
+   *
+   * @param scopesStorageFactory the custom factory, or null to use auto-detection
+   */
+  @ApiStatus.Experimental
+  public void setScopesStorageFactory(final @Nullable IScopesStorageFactory scopesStorageFactory) {
+    this.scopesStorageFactory = scopesStorageFactory;
+  }
+
   @ApiStatus.Experimental
   public @NotNull SentryOptions.Logs getLogs() {
     return logs;
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index 960b2838e2a..1fd8d9cc81f 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -964,4 +964,27 @@ class SentryOptionsTest {
     options.logs.loggerBatchProcessorFactory = mock
     assertSame(mock, options.logs.loggerBatchProcessorFactory)
   }
+
+  @Test
+  fun `scopesStorageFactory is null by default`() {
+    val options = SentryOptions()
+    assertNull(options.scopesStorageFactory)
+  }
+
+  @Test
+  fun `scopesStorageFactory can be set and retrieved`() {
+    val options = SentryOptions()
+    val factory = IScopesStorageFactory { _ -> DefaultScopesStorage() }
+    options.scopesStorageFactory = factory
+    assertSame(factory, options.scopesStorageFactory)
+  }
+
+  @Test
+  fun `scopesStorageFactory can be set to null`() {
+    val options = SentryOptions()
+    val factory = IScopesStorageFactory { _ -> DefaultScopesStorage() }
+    options.scopesStorageFactory = factory
+    options.scopesStorageFactory = null
+    assertNull(options.scopesStorageFactory)
+  }
 }
diff --git a/sentry/src/test/java/io/sentry/SentryTest.kt b/sentry/src/test/java/io/sentry/SentryTest.kt
index c3da8c1c123..25f45816b74 100644
--- a/sentry/src/test/java/io/sentry/SentryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTest.kt
@@ -1723,4 +1723,50 @@ class SentryTest {
       javaClass.injectForField("name", "io.sentry.SentryTest\$CustomAndroidOptions")
     }
   }
+
+  @Test
+  fun `when scopesStorageFactory is set, it is used instead of default storage`() {
+    val customStorage = mock<IScopesStorage>()
+    whenever(customStorage.set(anyOrNull())).thenReturn(mock())
+    whenever(customStorage.get()).thenReturn(null)
+
+    initForTest {
+      it.dsn = dsn
+      it.scopesStorageFactory = IScopesStorageFactory { _ -> customStorage }
+    }
+
+    verify(customStorage).init()
+    verify(customStorage).set(any())
+  }
+
+  @Test
+  fun `when scopesStorageFactory is null, default auto-detection is used`() {
+    initForTest {
+      it.dsn = dsn
+      it.scopesStorageFactory = null
+    }
+
+    // Should work normally with DefaultScopesStorage
+    val scopes = Sentry.getCurrentScopes()
+    assertFalse(scopes.isNoOp)
+  }
+
+  @Test
+  fun `custom scopes storage from factory is functional`() {
+    val backingStorage = DefaultScopesStorage()
+    val factoryCalled = AtomicBoolean(false)
+
+    initForTest {
+      it.dsn = dsn
+      it.scopesStorageFactory = IScopesStorageFactory { _ ->
+        factoryCalled.set(true)
+        backingStorage
+      }
+    }
+
+    assertTrue(factoryCalled.get())
+
+    val scopes = Sentry.getCurrentScopes()
+    assertFalse(scopes.isNoOp)
+  }
 }

From 23b2680687921bdefe78ce704f591f5eece7f640 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Wed, 25 Mar 2026 08:00:01 +0100
Subject: [PATCH 070/391] fix(replay): text layouts with center/end alignment
 return incorrect masking bounding box (#5218)

* Remove fill workaround, shortcut calculations if there's only one line of text

* changelog

* Revert "Remove fill workaround, shortcut calculations if there's only one line of text"

This reverts commit cfdcadcf866ea5572f154cf2781d90b97fdc0984.

* Work around erroneous paragraph return values

* Cover some more edge cases

* Format code

* Trigger Build

* fix dependencies

* Add snapshot tests for non-ellipsized multi-line text masking

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   4 +
 sentry-android-core/build.gradle.kts          |   7 +-
 .../core/ScreenshotEventProcessorTest.kt      | 392 ++++++++++++++++++
 .../screenshot_mask_all.png                   | Bin 2673 -> 2608 bytes
 ...eenshot_mask_ellipsized_compose_masked.png | Bin 0 -> 2917 bytes
 ...nshot_mask_ellipsized_compose_unmasked.png | Bin 0 -> 20367 bytes
 ...screenshot_mask_ellipsized_view_masked.png | Bin 0 -> 2331 bytes
 ...reenshot_mask_ellipsized_view_unmasked.png | Bin 0 -> 16750 bytes
 .../screenshot_mask_text.png                  | Bin 8428 -> 8366 bytes
 .../screenshot_multiline_compose_masked.png   | Bin 0 -> 3272 bytes
 .../screenshot_multiline_compose_unmasked.png | Bin 0 -> 28628 bytes
 .../screenshot_multiline_view_masked.png      | Bin 0 -> 2924 bytes
 .../screenshot_multiline_view_unmasked.png    | Bin 0 -> 20865 bytes
 .../io/sentry/android/replay/util/Nodes.kt    |  72 ++--
 .../sentry/android/replay/util/TextLayout.kt  |   8 +-
 .../io/sentry/android/replay/util/Views.kt    |  43 +-
 .../viewhierarchy/ComposeViewHierarchyNode.kt |   7 +-
 17 files changed, 460 insertions(+), 73 deletions(-)
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_masked.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_unmasked.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_masked.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_unmasked.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_masked.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_unmasked.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_masked.png
 create mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_unmasked.png

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cbc6651ce34..65b59334d90 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+
+- Session Replay: Fix Compose text masking mismatch with weighted text ([#5218](https://github.com/getsentry/sentry-java/pull/5218))
+
 ### Features
 
 - Add configurable `IScopesStorageFactory` to `SentryOptions` for providing a custom `IScopesStorage`, e.g. when the default `ThreadLocal`-backed storage is incompatible with non-pinning thread models ([#5199](https://github.com/getsentry/sentry-java/pull/5199))
diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index 1134e948226..ffd42c7d4d7 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -4,6 +4,7 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion
 plugins {
   id("com.android.library")
   alias(libs.plugins.kotlin.android)
+  alias(libs.plugins.kotlin.compose)
   jacoco
   alias(libs.plugins.jacoco.android)
   alias(libs.plugins.errorprone)
@@ -108,7 +109,11 @@ dependencies {
   testImplementation(projects.sentryCompose)
   testImplementation(projects.sentryAndroidNdk)
   testImplementation(libs.dropbox.differ)
-  testRuntimeOnly(libs.androidx.compose.ui)
+  testImplementation(libs.androidx.activity.compose)
+  testImplementation(libs.androidx.compose.ui)
+  testImplementation(libs.androidx.compose.foundation)
+  testImplementation(libs.androidx.compose.foundation.layout)
+  testImplementation(libs.androidx.compose.material3)
   testRuntimeOnly(libs.androidx.fragment.ktx)
   testRuntimeOnly(libs.timber)
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt
index acc38228e6b..300936153f7 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt
@@ -9,12 +9,27 @@ import android.graphics.Color
 import android.graphics.drawable.Drawable
 import android.os.Bundle
 import android.os.Looper
+import android.text.TextUtils
 import android.view.View
 import android.widget.ImageView
 import android.widget.LinearLayout
 import android.widget.LinearLayout.LayoutParams
 import android.widget.RadioButton
 import android.widget.TextView
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Text
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import com.dropbox.differ.Color as DifferColor
 import com.dropbox.differ.Image
@@ -410,6 +425,84 @@ class ScreenshotEventProcessorTest {
     assertNotNull(bytes)
   }
 
+  @Test
+  fun `snapshot - screenshot with ellipsized text no masking`() {
+    fixture.activity = buildActivity(EllipsizedTextActivity::class.java, null).setup().get()
+    val bytes =
+      processEventForSnapshots(
+        "screenshot_mask_ellipsized_view_unmasked",
+        isReplayAvailable = false,
+      )
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - screenshot with ellipsized text masking`() {
+    fixture.activity = buildActivity(EllipsizedTextActivity::class.java, null).setup().get()
+    val bytes =
+      processEventForSnapshots("screenshot_mask_ellipsized_view_masked") {
+        it.screenshot.setMaskAllText(true)
+      }
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - compose text no masking`() {
+    fixture.activity = buildActivity(ComposeTextActivity::class.java, null).setup().get()
+    val bytes =
+      processEventForSnapshots(
+        "screenshot_mask_ellipsized_compose_unmasked",
+        isReplayAvailable = false,
+      )
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - compose text with masking`() {
+    fixture.activity = buildActivity(ComposeTextActivity::class.java, null).setup().get()
+    val bytes =
+      processEventForSnapshots("screenshot_mask_ellipsized_compose_masked") {
+        it.screenshot.setMaskAllText(true)
+      }
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - multiline view text no masking`() {
+    fixture.activity = buildActivity(MultiLineTextActivity::class.java, null).setup().get()
+    val bytes =
+      processEventForSnapshots("screenshot_multiline_view_unmasked", isReplayAvailable = false)
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - multiline view text with masking`() {
+    fixture.activity = buildActivity(MultiLineTextActivity::class.java, null).setup().get()
+    val bytes =
+      processEventForSnapshots("screenshot_multiline_view_masked") {
+        it.screenshot.setMaskAllText(true)
+      }
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - multiline compose text no masking`() {
+    fixture.activity = buildActivity(ComposeMultiLineTextActivity::class.java, null).setup().get()
+    val bytes =
+      processEventForSnapshots("screenshot_multiline_compose_unmasked", isReplayAvailable = false)
+    assertNotNull(bytes)
+  }
+
+  @Test
+  fun `snapshot - multiline compose text with masking`() {
+    fixture.activity = buildActivity(ComposeMultiLineTextActivity::class.java, null).setup().get()
+    val bytes =
+      processEventForSnapshots("screenshot_multiline_compose_masked") {
+        it.screenshot.setMaskAllText(true)
+      }
+    assertNotNull(bytes)
+  }
+
   // endregion
 
   private fun getEvent(): SentryEvent = SentryEvent(Throwable("Throwable"))
@@ -484,6 +577,305 @@ private class CustomView(context: Context) : View(context) {
   }
 }
 
+private class EllipsizedTextActivity : Activity() {
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val longText = "This is a very long text that should be ellipsized when it does not fit"
+
+    val linearLayout =
+      LinearLayout(this).apply {
+        setBackgroundColor(Color.WHITE)
+        orientation = LinearLayout.VERTICAL
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        setPadding(10, 10, 10, 10)
+      }
+
+    // Ellipsize end
+    linearLayout.addView(
+      TextView(this).apply {
+        text = longText
+        setTextColor(Color.BLACK)
+        textSize = 16f
+        maxLines = 1
+        ellipsize = TextUtils.TruncateAt.END
+        setBackgroundColor(Color.LTGRAY)
+        layoutParams =
+          LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply {
+            setMargins(0, 8, 0, 0)
+          }
+      }
+    )
+
+    // Ellipsize middle
+    linearLayout.addView(
+      TextView(this).apply {
+        text = longText
+        setTextColor(Color.BLACK)
+        textSize = 16f
+        maxLines = 1
+        ellipsize = TextUtils.TruncateAt.MIDDLE
+        setBackgroundColor(Color.LTGRAY)
+        layoutParams =
+          LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply {
+            setMargins(0, 8, 0, 0)
+          }
+      }
+    )
+
+    // Ellipsize start
+    linearLayout.addView(
+      TextView(this).apply {
+        text = longText
+        setTextColor(Color.BLACK)
+        textSize = 16f
+        maxLines = 1
+        ellipsize = TextUtils.TruncateAt.START
+        setBackgroundColor(Color.LTGRAY)
+        layoutParams =
+          LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply {
+            setMargins(0, 8, 0, 0)
+          }
+      }
+    )
+
+    // Non-ellipsized text for comparison
+    linearLayout.addView(
+      TextView(this).apply {
+        text = "Short text"
+        setTextColor(Color.BLACK)
+        textSize = 16f
+        setBackgroundColor(Color.LTGRAY)
+        layoutParams =
+          LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply {
+            setMargins(0, 8, 0, 0)
+          }
+      }
+    )
+
+    setContentView(linearLayout)
+  }
+}
+
+private class ComposeTextActivity : ComponentActivity() {
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val longText = "This is a very long text that should be ellipsized when it does not fit in view"
+
+    setContent {
+      Column(
+        modifier =
+          Modifier.fillMaxWidth()
+            .background(androidx.compose.ui.graphics.Color.White)
+            .padding(10.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+      ) {
+        // Ellipsis overflow
+        Text(
+          longText,
+          maxLines = 1,
+          overflow = TextOverflow.Ellipsis,
+          fontSize = 16.sp,
+          modifier =
+            Modifier.fillMaxWidth().background(androidx.compose.ui.graphics.Color.LightGray),
+        )
+
+        // Text with textAlign center
+        Text(
+          "Centered text",
+          textAlign = TextAlign.Center,
+          fontSize = 16.sp,
+          modifier =
+            Modifier.fillMaxWidth().background(androidx.compose.ui.graphics.Color.LightGray),
+        )
+
+        // Text with textAlign end
+        Text(
+          "End-aligned text",
+          textAlign = TextAlign.End,
+          fontSize = 16.sp,
+          modifier =
+            Modifier.fillMaxWidth().background(androidx.compose.ui.graphics.Color.LightGray),
+        )
+
+        // Ellipsis with textAlign center
+        Text(
+          longText,
+          maxLines = 1,
+          overflow = TextOverflow.Ellipsis,
+          textAlign = TextAlign.Center,
+          fontSize = 16.sp,
+          modifier =
+            Modifier.fillMaxWidth().background(androidx.compose.ui.graphics.Color.LightGray),
+        )
+
+        // Weighted row with text
+        Row(
+          modifier = Modifier.fillMaxWidth(),
+          horizontalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+          Text(
+            "Weight 1",
+            fontSize = 16.sp,
+            modifier = Modifier.weight(1f).background(androidx.compose.ui.graphics.Color.LightGray),
+          )
+          Text(
+            "Weight 1",
+            fontSize = 16.sp,
+            modifier = Modifier.weight(1f).background(androidx.compose.ui.graphics.Color.LightGray),
+          )
+        }
+
+        // Weighted row with ellipsized text
+        Row(
+          modifier = Modifier.fillMaxWidth(),
+          horizontalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+          Text(
+            longText,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            fontSize = 16.sp,
+            modifier = Modifier.weight(1f).background(androidx.compose.ui.graphics.Color.LightGray),
+          )
+          Text(
+            longText,
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis,
+            textAlign = TextAlign.End,
+            fontSize = 16.sp,
+            modifier = Modifier.weight(1f).background(androidx.compose.ui.graphics.Color.LightGray),
+          )
+        }
+
+        // Short text (for comparison)
+        Text(
+          "Short text",
+          fontSize = 16.sp,
+          modifier = Modifier.background(androidx.compose.ui.graphics.Color.LightGray),
+        )
+      }
+    }
+  }
+}
+
+private class MultiLineTextActivity : Activity() {
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val multiLineText =
+      "This is a long text that will wrap across multiple lines without being ellipsized. " +
+        "It should continue to flow naturally within the available width of the view."
+
+    val linearLayout =
+      LinearLayout(this).apply {
+        setBackgroundColor(Color.WHITE)
+        orientation = LinearLayout.VERTICAL
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        setPadding(10, 10, 10, 10)
+      }
+
+    // Multi-line wrapping text (no maxLines, no ellipsize)
+    linearLayout.addView(
+      TextView(this).apply {
+        text = multiLineText
+        setTextColor(Color.BLACK)
+        textSize = 16f
+        setBackgroundColor(Color.LTGRAY)
+        layoutParams =
+          LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply {
+            setMargins(0, 8, 0, 0)
+          }
+      }
+    )
+
+    // Multi-line text with maxLines = 3 (wraps but capped)
+    linearLayout.addView(
+      TextView(this).apply {
+        text = multiLineText
+        setTextColor(Color.BLACK)
+        textSize = 16f
+        maxLines = 3
+        setBackgroundColor(Color.LTGRAY)
+        layoutParams =
+          LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply {
+            setMargins(0, 8, 0, 0)
+          }
+      }
+    )
+
+    // Short single-line text for comparison
+    linearLayout.addView(
+      TextView(this).apply {
+        text = "Short text"
+        setTextColor(Color.BLACK)
+        textSize = 16f
+        setBackgroundColor(Color.LTGRAY)
+        layoutParams =
+          LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT).apply {
+            setMargins(0, 8, 0, 0)
+          }
+      }
+    )
+
+    setContentView(linearLayout)
+  }
+}
+
+private class ComposeMultiLineTextActivity : ComponentActivity() {
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val multiLineText =
+      "This is a long text that will wrap across multiple lines without being ellipsized. " +
+        "It should continue to flow naturally within the available width of the view."
+
+    setContent {
+      Column(
+        modifier =
+          Modifier.fillMaxWidth()
+            .background(androidx.compose.ui.graphics.Color.White)
+            .padding(10.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+      ) {
+        // Multi-line wrapping text (no maxLines, no overflow)
+        Text(
+          multiLineText,
+          fontSize = 16.sp,
+          modifier =
+            Modifier.fillMaxWidth().background(androidx.compose.ui.graphics.Color.LightGray),
+        )
+
+        // Multi-line text with maxLines = 3
+        Text(
+          multiLineText,
+          maxLines = 3,
+          fontSize = 16.sp,
+          modifier =
+            Modifier.fillMaxWidth().background(androidx.compose.ui.graphics.Color.LightGray),
+        )
+
+        // Multi-line centered text
+        Text(
+          multiLineText,
+          textAlign = TextAlign.Center,
+          fontSize = 16.sp,
+          modifier =
+            Modifier.fillMaxWidth().background(androidx.compose.ui.graphics.Color.LightGray),
+        )
+
+        // Short text for comparison
+        Text(
+          "Short text",
+          fontSize = 16.sp,
+          modifier = Modifier.background(androidx.compose.ui.graphics.Color.LightGray),
+        )
+      }
+    }
+  }
+}
+
 private class MaskingActivity : Activity() {
 
   override fun onCreate(savedInstanceState: Bundle?) {
diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_all.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_all.png
index 31ba5f581bcfc891c1c1eef20d9106580c53c0ae..aa1ec41ee06c2a1dbbd7292cf8629935c5c9b634 100644
GIT binary patch
literal 2608
zcmeHJSx}Q#6#jqy6oLgwt%ig^g42<XN`rA>%_faSY5~U;WG$hA4od`N69_5FfCW*9
zQ4mz>Sgi|$6h;yUBrFm{1gZ#xKnQ_}tOAiG34zc*ee*%9Qy+Zjow;-8+~v&qzVqF4
z@0tDH9_DMT)&Kxt?zxw7002Nb+<TD5@QiWA{&{!+;}3Ya1H2CFao9k_yL%o&!YvIM
zmIDB$QcuS2L&;ZO$w)r_M<K2PdeRu2LovRSyLEfwlfQ1}m9-X^UfgBVMGD-q>tM^?
zAMY@}n-ZPBz`h-|No&+F6f&zLe>K#m_+G6Hkf)wgi!qjvZA3;t1W3>zq7s36ypC?W
z5BSCYtwxy#EpEip5?u`Pss#eULpg<0ALrX>QWlBZI1mA3SqRH(%oO55Xgw|D%jwEZ
z#7w{sXZl+of$y2ry?zJXcCrWDse?GDYa(*7w&yo->6ZW_KO<zA>AQ@CNg!qp^5V)8
zETc&fqSA34y^0=EFnxD3i%ahj8%3azQH_Dsk4$br>c&&6A@dcc8)qr~<kaQsAVSy~
zfB@eIn*lZ6#>OUn4mTqgiAJsuIQW!OWs4{-A!=r9Y%EvFpHS$~q|>tb=FNOfddZ4W
z&CeU?Cfe>Pf`p=DItwe>IGM8HE!)oDXCHwMT?TorG&70Ko9Kjg=b9U)B}sJXupxLo
z#(R=yI96E<x(X{;tM${`;q{W;`sl^ar*5tKqZZ<oEp-fwMEOM!A^C}C1pO;pZ;-k$
zc9*SRYV%3jl^>~{EX@#55Fy!V@w;E>&~-3NeA8gWY+d$Dq&spzJVB|?MvF-Jmqowm
zn)aY<BQx@{DFr7VGfk@7%utV|@+|BN;<9<YYzLf!_Ylk5W%R)-k*gIMdf6f-CfZVO
zJT!e7H1g9i$y3-D-{Rf)fd(SCa4ll(7Emo_1B6r$4-d=W3{`J1M=JK^d1<&_8WvDE
z?T^f|ko>+CLh{=_KoV~UiZ9n?_C-0`6|_2&$<_s}VR<BR8kG<p9?qnep6lxBI%_ty
zqEqAgI*2Jt^W)XofSXcE$aT5u-7+`YdGuM$Q+T&%Rj+fV(L~R<r)N$+LdDD+1Ibh>
zUbM2<k74FDhmxpinr&3hvhde|6RtKs*T`7f>hfIjvPK0j3)u2}*o-f4$dR99pkhXA
zz-2OLX7C}7Jy`o-KHOsMTCqx{N?x4mgLl*P8s_qfTHb4wqmkty8`}d@z6f)@${SWs
zbl=-L;v~kDQq!&Alh}%&hgQtI*todux4OoYOg3_y!sQL^f!KOWhoC%?zC>FdA3HKX
zf1);39Rq`g(XdHmE@AXJ(7~!wX;dSB`r6mI&FL-~0)#QZ6cx3z3iVg8X8dmojgO~H
zEGe3@anYKtKYZ@>29544Dw*>^#JqeC;PLo;l2`+~IO|lG_A1UFP`BO$0|q<dx^!A<
z#y=BhJQUoreUQ-CUW^f>uEuDk%4%S`U>}s6nCK|RjI<Vf?KG%)eZMVQ#S~(#3~q^X
zQAs;%WN0Yll{vxMx-2H+!9+U4#K92FEDR)pAcuL9;;1n7a3bx|xo68!5a07?5F%w|
zX#plLyz^RM%8t2SR#o3b%8=5L7m7}fU$hw*xCoMIwBYiw*RPdrFk^Ab@!5uk24@!+
ztV3{}HFH^jX-r_>h_$Wgq@L>cOLZyJrqvx=8wo3fBrf{F?w*o=Y4S5()w-vn<nH5?
zVH1I%C-b&LP_1U#t39_lw3f57bi`@D!x=>(!@_Y=3I-InvzV?|^P8HQ4x3r#Haoky
z;YLSCiOGP4SPIvO4frhRzu(S9B9WLld{B|bBJzoF-G1k*@WI#l<9drUROitCQ-H+y
o6OZ)c;{M;;r>)EP&rjJZSjl6n5Eo>4_}2$`?(t^u+(R<|28Xc1xBvhE

literal 2673
zcmeAS@N?(olHy`uVBq!ia0y~yU~~ZDYaDDq5w`UKUw{;2age(c!@6@aFM%AEVkgfK
z4j`!ENa<i;;F9)qaSW-L^Y-q3Kj}>AV-MM<h}f~d5n7Tfb5m9Hs2FE#fK`U2PSiFP
z)yy!itJ6F#tYPtLt>s$sSUc?7^m;Q1e~AyZv8h7-ayn0^m)krpzqabtItHe-+ie*f
zqFDqwR2v+07+I1y6$HE)8Y7rEjtDs@Ok-f$h$8j+>U*0Xcjxw|HQc;*?b@xszh9f@
zw5!$}P`bsHxR_DIE<w^?_RujqW)b^@NdLQn;*Jdwy(|}A@n@V0{&s{*pkr$Z!`goh
z%WOl#*Wk7U!+xNy+jT2AH&o4Ar5)Dbu*QukLzKhhsb+N&E60&6orbW+1DodUQkLuC
z+mfd$*Yi(Vk>y$D?=v5_vk5$~EEZ%T&Tk-V*RwSr)USX1=g*%`_e#6A!-=<*8T=D+
z4J2x|%Z3&GsB`5>EUhi)(y6omJnz7(S!@^VzueqozG2q2)qj}lIo=Ddkqd7W|M2hc
z?``f3Qd{y;KNsZMA7IV6c5ANtcHJYPi4n4XjVOUzz?gr3Uv4$a0>{_uvh41>zP|pp
z9Am}=(FaW1wr>Y9FO--|n7f?czIShI{QkP!YMup-mqix@KfKv?c;SzOT)*ClM6lF9
zvu(Wk^>W*a`(C!XVzws?%o`Y1p9xLCj6aN^MUD0K&;CA}f4ko1sto_9@Am(<*)nZ#
zs@tjfs+jwJe~UoIp>oEWcMpG06ks|%qmJ#zrAOgkjndiX@q?oIb*O%|>eor>?6*>Z
zkrEZ(Dtblh56^+io0$luDFSZ7krD~$dR_njbN+2(om|m6wg)dG8JRX-TOId}>y_$x
zzAdML3DK1Ifp?7O-Xk*`pC<#O_s-uR-Sv6@FCNq3SF3Rlu9G~_`CQEDA@eK~a8SAm
zkQ|iQoV_>d3+vyy{k!hw<>uywZoj>D)vAjbA>rZSrc%AHK7HCW@!+}h=cO&rt&-qt
z&+TW>etxk3=$o%qTlep`@4ct9_~MFxzh1B3wR30X6^BFR_J%EKHX04PckllC?(XhY
ztEBpmmlhTVUcY|*@`<lidvD#jv&KCC-j!p=+(JX=&YO2_x&M4IDYrjzek_TV-`PIg
z{xNs%+^Z)~o;+iJ`(;U1dHMFTva(gHUOhhE|MlnR=j^;nb=|^_5$Eo7E9{NSm)gI0
z@#38ySFhT&ckkNClP6nQS*=>NYVY2?ufA4&=Toffe_Y%A^bGHVg9jZ$|8D;j{p8WH
zr%zLXHiU*={rB&m&|}6wcE-#%-ha<dPF{TM@yET|`{ONbZP$LRh`F1${ny`rXYA8O
znYW~-F{m$JCoV4DZ}s8r+qYk~@>}vgEBwRG)NgLw5FH&I8d_Rg`}ak&f1I_Y*nwgr
z<A%w%Bju{??{8l}SBCq6<;PG9g==RR`i?(d74`1(?vvT-$C)bp(%3${dIfZ@nYp=q
z?FW$HqRRMvHJQ~c6&uso3O@ae-G6_*-}22L8m;G^`|@pi<$UE|X3Q6+&1BrOXV08_
z$F~E+_(NlPdHL$wZ?9F@<mI$WG^m~3%TZKQ6B8P0ZEangpY|_s|NZ%O@)borm1~&f
z(=BAKwe!p0l4Firvy*Yp&Yd&gy(p@vh^VfvF7|J?p6dtn+|`E<6M<nRdB{0`vEad@
z75ft^x%1nBDPh^|#9p_>z^EwOefjMMwco6In}pA7ui5;t?h*Uhhz#c|&CSi#`B`$n
z_^zqhbA|VcaMF+ZMeJv*3mDXY{jCGV{jFQGjuqI*UB7xY^zNNIJ039Zk>F+*NC^F*
zC4;YYCy=KQN&4EmckjX;tt^-~n_K4;FgKx=A_#RTbqCR=(?Zu)GYOt|x8#@>@B%9k
t!u8yMx^?h}=BNv?H;)D;*<Ab2u&S*gFhWOQ3b5J8;OXk;vd$@?2>?^=z1{!-

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_masked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_masked.png
new file mode 100644
index 0000000000000000000000000000000000000000..53e5a236c3e86ca447dd8674c6d046302bd8cda1
GIT binary patch
literal 2917
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
EZ)r_j+5i9m

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_unmasked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_unmasked.png
new file mode 100644
index 0000000000000000000000000000000000000000..efc2304c4f2db20dc4d7d5ee73a741da009a9001
GIT binary patch
literal 20367
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

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_masked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_masked.png
new file mode 100644
index 0000000000000000000000000000000000000000..1530d58fd9af3df79b8339c8b953b12c4df77535
GIT binary patch
literal 2331
zcmeAS@N?(olHy`uVBq!ia0y~yU~~ZDYaDDq5w`UKUw{;2age(c!@6@aFM%AEVkgfK
z4j`!ENa<i;;5h2(;uumf=j~m?yxUPs4uORersVCJs-k@&Y11->IM1#vnkhRy-|{Zu
zoM6_v{D**naF4o*YuBWAmTP?`78QQ<u(RXaefM1|yTF(AYxx-xw3#?kI29(SHaJXU
zV2Z@e$-nmJ({yp}vkd?58}QtITfO~IQN$s3pRKMO;=Bt!FfO-B=Mdk`rcrl5=-f>q
zbH|1?u1pzU*mYjU_!=^?Z1Uq<a8Z6kTk)2o90DhV92C468g&?1HnHI2SXnki@4LXV
zBldYlx1hp=tsV@$OpU5@S8KX8I9y9&G~r^IR&Z`wg`rh};JSZDU(^dZJ;>i?QypX4
zz%c!cuK-bY0G;x>S9NuRmNIc}LU;P>vp4K*Wcb$Cef#(Kw<{mpgM2x8`TxJn-{0FS
z{WW$m^N;-;@&$Rv-}P`lynluZ7*5gAN-dMuGj_=rc=}~dnyuh)?FECKy}k5bM)AzN
z*>3C~UcSt{#>b#{^@Gu;vo8)Ctf|#uP`A7%AZg8e%oMvD-Pj8{r;0ONGg=-93YjGg
zQmjnVGxBElFf^_?2?{2?lbXJ>wkmxoY@c?VY1^iolYZ38H3%?0-}EH%#fzsK81j07
z?!XrNz4JI~Eo9>Uo^i=Y&@EQ8>#x;)=IP(WA-`c;a{9H1_JlBoR(^}^rcM?=r55~P
zjE>smnAgM*3H0`#KRI96V_KF*nOHUW`}=pl5qJ>P6UUb=(YCdpHDS{AypEo^Y>%a|
zr@O_>JC1qrFcjDR{q^<9djlqxb(anwK78`NVW#Dp<Hz04Gc(Wr{psoHcR=vuy=A6j
zNQ3U3`}g%f*-rLvjOAw8wk4%Gt(T#n{XvO@#q{n-q5mEnja%1NUbC#S)M<!Lmg2#h
z+83)k$@8^`+Zzi?Mckgkc`-S@yYkXxg+uIfPH!}yZO^S!b0BOQ&%-C#4UgDknpC5n
zsBug%)ogI9KcH&4)zhuvK<MwkzrVl9b=Pk<<vILjF2kCa=cSdBmmid1WD0-(`}_ON
z+k_n+y!!j&WAe2!CXSfB{qpwbZuuc+gzOTA>ow-;2V&;i*WUwrKKt4>u(@AeUViuR
zVdAxIlcycN_5S;AetEkyw*(Jd`u6+pyXWWU?*@X%+x}b&jz4VhHsU$_?%%(<Z{Hw+
zp?6S77aaG;fpLE>_p|E9{uTj?>89uGfbL{1$o6Sw#Fh)Qzqq_O{P4r8^zAl+w-(nI
z)E?U>_IZiAW1eM=`|<l4Ed|wStQ!RO*>fu1nRoI!L-)tu{$KC&Z$ARecG*D;y><T{
z{%6>J5SZ7cWE~dI`~U1e<Ms2{bN-r(jCbCD&z3uWb)yDT%>IjvGHr=xA2V3&_FR6z
z&G!F~Z*Om3YiH0oV0u9E-oD!1Ulkd+XUH7*rLp1P?}yXQL<#<qXuQ<KaEN{T^Cjg?
zB2F4L1-sj(1HoE;rUY(KYQ$ZnjmqFF@JB;uG<2|43dA%P2&J8``C;6mtsRF7rGO0_
N22WQ%mvv4FO#mO{7J~o)

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_unmasked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_unmasked.png
new file mode 100644
index 0000000000000000000000000000000000000000..57b4bfa8f42f9b911ce06a8d5835799d472b4c58
GIT binary patch
literal 16750
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
Joz=bjzW@p0?Kc1b

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_text.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_text.png
index 952fd6ba634e63272feab38bb17f8ee73e2b2267..6ffbe1e07f5ec41580bf25ba1b5c317b608ae804 100644
GIT binary patch
delta 6669
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

delta 6757
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
WvN9z3KmMC@0!3LhnNn%ffd2=;$axF^

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_masked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_masked.png
new file mode 100644
index 0000000000000000000000000000000000000000..fb8f816218d0610b70c51cf01fc4a13ada281590
GIT binary patch
literal 3272
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

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_unmasked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_unmasked.png
new file mode 100644
index 0000000000000000000000000000000000000000..dc4beee80a68507a82bce68ebd330f48314fabe5
GIT binary patch
literal 28628
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

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_masked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_masked.png
new file mode 100644
index 0000000000000000000000000000000000000000..373752de30f95ef642b961822be5ddcdbdeb9cba
GIT binary patch
literal 2924
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

literal 0
HcmV?d00001

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_unmasked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_unmasked.png
new file mode 100644
index 0000000000000000000000000000000000000000..df051c63713c9b9d8cb2d85f9fd3adfae3eed7fa
GIT binary patch
literal 20865
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
b!SZ?X^rEP%{zTCDL=a^Kb@@VBlc)b1?Z&sE

literal 0
HcmV?d00001

diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
index 1d779d389bf..cd9e3dd208a 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
@@ -13,38 +13,39 @@ import androidx.compose.ui.node.LayoutNode
 import androidx.compose.ui.text.TextLayoutResult
 import kotlin.math.roundToInt
 
-internal class ComposeTextLayout(
-  internal val layout: TextLayoutResult,
-  private val hasFillModifier: Boolean,
-) : TextLayout {
+internal class ComposeTextLayout(internal val layout: TextLayoutResult) : TextLayout {
   override val lineCount: Int
     get() = layout.lineCount
 
   override val dominantTextColor: Int?
     get() = null
 
-  override fun getPrimaryHorizontal(line: Int, offset: Int): Float {
-    val horizontalPos = layout.getHorizontalPosition(offset, usePrimaryDirection = true)
-    // when there's no `fill` modifier on a Text composable, compose still thinks that there's
-    // one and wrongly calculates horizontal position relative to node's start, not text's start
-    // for some reason. This is only the case for single-line text (multiline works fien).
-    // So we subtract line's left to get the correct position
-    return if (!hasFillModifier && lineCount == 1) {
-      horizontalPos - layout.getLineLeft(line)
-    } else {
-      horizontalPos
+  /**
+   * The paragraph may be laid out with a wider width (constraint maxWidth) than the actual node
+   * (layout result size). When that happens, getLineLeft/getLineRight return positions in the
+   * paragraph coordinate system, which don't match the node's bounds. In that case, text alignment
+   * has no visible effect, so we fall back to using line width starting from x=0.
+   */
+  private val paragraphWidthExceedsNode: Boolean
+    get() = layout.multiParagraph.width > layout.size.width
+
+  override fun getLineLeft(line: Int): Float {
+    if (paragraphWidthExceedsNode) {
+      return 0f
     }
+    return layout.getLineLeft(line)
   }
 
-  override fun getEllipsisCount(line: Int): Int = if (layout.isLineEllipsized(line)) 1 else 0
-
-  override fun getLineVisibleEnd(line: Int): Int = layout.getLineEnd(line, visibleEnd = true)
+  override fun getLineRight(line: Int): Float {
+    if (paragraphWidthExceedsNode) {
+      return layout.multiParagraph.getLineWidth(line)
+    }
+    return layout.getLineRight(line)
+  }
 
   override fun getLineTop(line: Int): Int = layout.getLineTop(line).roundToInt()
 
   override fun getLineBottom(line: Int): Int = layout.getLineBottom(line).roundToInt()
-
-  override fun getLineStart(line: Int): Int = layout.getLineStart(line)
 }
 
 // TODO: probably most of the below we can do via bytecode instrumentation and speed up at runtime
@@ -92,8 +93,6 @@ internal fun Painter.isMaskable(): Boolean {
     !className.contains("Brush")
 }
 
-internal data class TextAttributes(val color: Color?, val hasFillModifier: Boolean)
-
 /**
  * This method is necessary to mask text in Compose.
  *
@@ -101,37 +100,24 @@ internal data class TextAttributes(val color: Color?, val hasFillModifier: Boole
  * string in their name, e.g. TextStringSimpleElement or TextAnnotatedStringElement. We then get the
  * color from the modifier, to be able to mask it with the correct color.
  *
- * We also look up for classes that have a [Fill] modifier, usually they all have a `Fill` string in
- * their name, e.g. FillElement. This is necessary to workaround a Compose bug where single-line
- * text composable without a `fill` modifier still thinks that there's one and wrongly calculates
- * horizontal position.
- *
  * We also add special proguard rules to keep the `Text` class names and their `color` member.
  */
-internal fun LayoutNode.findTextAttributes(): TextAttributes {
+internal fun LayoutNode.findTextColor(): Color? {
   val modifierInfos = getModifierInfo()
-  var color: Color? = null
-  var hasFillModifier = false
   for (index in modifierInfos.indices) {
     val modifier = modifierInfos[index].modifier
     val modifierClassName = modifier::class.java.name
     if (modifierClassName.contains("Text")) {
-      color =
-        try {
-          (modifier::class
-              .java
-              .getDeclaredField("color")
-              .apply { isAccessible = true }
-              .get(modifier) as? ColorProducer)
-            ?.invoke()
-        } catch (e: Throwable) {
-          null
-        }
-    } else if (modifierClassName.contains("Fill")) {
-      hasFillModifier = true
+      return try {
+        (modifier::class.java.getDeclaredField("color").apply { isAccessible = true }.get(modifier)
+            as? ColorProducer)
+          ?.invoke()
+      } catch (e: Throwable) {
+        null
+      }
     }
   }
-  return TextAttributes(color, hasFillModifier)
+  return null
 }
 
 /**
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/TextLayout.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/TextLayout.kt
index 9b974efceaa..e62584bda06 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/TextLayout.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/TextLayout.kt
@@ -13,15 +13,11 @@ internal interface TextLayout {
    */
   val dominantTextColor: Int?
 
-  fun getPrimaryHorizontal(line: Int, offset: Int): Float
+  fun getLineLeft(line: Int): Float
 
-  fun getEllipsisCount(line: Int): Int
-
-  fun getLineVisibleEnd(line: Int): Int
+  fun getLineRight(line: Int): Float
 
   fun getLineTop(line: Int): Int
 
   fun getLineBottom(line: Int): Int
-
-  fun getLineStart(line: Int): Int
 }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt
index 80ca1beee4e..d0583cdaa6a 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt
@@ -128,21 +128,14 @@ internal fun TextLayout?.getVisibleRects(
 
   val rects = mutableListOf<Rect>()
   for (i in 0 until lineCount) {
-    val lineStart = getPrimaryHorizontal(i, getLineStart(i)).toInt()
-    val ellipsisCount = getEllipsisCount(i)
-    val lineVisibleEnd = getLineVisibleEnd(i)
-    var lineEnd =
-      getPrimaryHorizontal(i, lineVisibleEnd - ellipsisCount + if (ellipsisCount > 0) 1 else 0)
-        .toInt()
-    if (lineEnd == 0 && lineVisibleEnd > 0) {
-      // looks like the case for when emojis are present in text
-      lineEnd = getPrimaryHorizontal(i, lineVisibleEnd - 1).toInt() + 1
-    }
+    val lineLeft = getLineLeft(i).toInt()
+    val lineRight = getLineRight(i).toInt()
     val lineTop = getLineTop(i)
     val lineBottom = getLineBottom(i)
     val rect = Rect()
-    rect.left = globalRect.left + paddingLeft + lineStart
-    rect.right = rect.left + (lineEnd - lineStart)
+
+    rect.left = globalRect.left + paddingLeft + lineLeft
+    rect.right = globalRect.left + paddingLeft + lineRight
     rect.top = globalRect.top + paddingTop + lineTop
     rect.bottom = rect.top + (lineBottom - lineTop)
 
@@ -197,18 +190,30 @@ internal class AndroidTextLayout(private val layout: Layout) : TextLayout {
       return dominantColor?.toOpaque()
     }
 
-  override fun getPrimaryHorizontal(line: Int, offset: Int): Float =
-    layout.getPrimaryHorizontal(offset)
-
-  override fun getEllipsisCount(line: Int): Int = layout.getEllipsisCount(line)
+  /**
+   * If text gets ellipsized, we return the left and right bounds of the ellipsized text instead of
+   * the width, as it's set to some obscure VERY_WIDE value. E.g. see
+   * https://cs.android.com/android/platform/superproject/main/+/main:frameworks/base/core/java/android/widget/TextView.java;l=468?q=VERY_WIDE
+   */
+  override fun getLineLeft(line: Int): Float {
+    return if (layout.ellipsizedWidth > 0 && layout.ellipsizedWidth < layout.width) {
+      0f
+    } else {
+      layout.getLineLeft(line)
+    }
+  }
 
-  override fun getLineVisibleEnd(line: Int): Int = layout.getLineVisibleEnd(line)
+  override fun getLineRight(line: Int): Float {
+    return if (layout.ellipsizedWidth > 0 && layout.ellipsizedWidth < layout.width) {
+      layout.ellipsizedWidth.toFloat()
+    } else {
+      layout.getLineRight(line)
+    }
+  }
 
   override fun getLineTop(line: Int): Int = layout.getLineTop(line)
 
   override fun getLineBottom(line: Int): Int = layout.getLineBottom(line)
-
-  override fun getLineStart(line: Int): Int = layout.getLineStart(line)
 }
 
 internal fun View?.addOnDrawListenerSafe(listener: ViewTreeObserver.OnDrawListener) {
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
index f421ff9ad07..ec01d28d4fb 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
@@ -24,7 +24,7 @@ import io.sentry.android.replay.SentryReplayModifiers
 import io.sentry.android.replay.util.ComposeTextLayout
 import io.sentry.android.replay.util.boundsInWindow
 import io.sentry.android.replay.util.findPainter
-import io.sentry.android.replay.util.findTextAttributes
+import io.sentry.android.replay.util.findTextColor
 import io.sentry.android.replay.util.isMaskable
 import io.sentry.android.replay.util.toOpaque
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.GenericViewHierarchyNode
@@ -189,11 +189,10 @@ internal object ComposeViewHierarchyNode {
           ?.action
           ?.invoke(textLayoutResults)
 
-        val (color, hasFillModifier) = node.findTextAttributes()
         val textLayoutResult = textLayoutResults.firstOrNull()
         var textColor = textLayoutResult?.layoutInput?.style?.color
         if (textColor?.isUnspecified == true) {
-          textColor = color
+          textColor = node.findTextColor()
         }
         val isLaidOut = textLayoutResult?.layoutInput?.style?.fontSize != TextUnit.Unspecified
         // TODO: support editable text (currently there's a way to get @Composable's padding only
@@ -202,7 +201,7 @@ internal object ComposeViewHierarchyNode {
         TextViewHierarchyNode(
           layout =
             if (textLayoutResult != null && !isEditable && isLaidOut) {
-              ComposeTextLayout(textLayoutResult, hasFillModifier)
+              ComposeTextLayout(textLayoutResult)
             } else {
               null
             },

From 028aa67fabce3d2f9caa097bd4e2d13be6ba7b85 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 25 Mar 2026 11:13:59 +0100
Subject: [PATCH 071/391] feat(spring): Cache Tracing (#5165)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(spring): [Cache Tracing 1] Add SentryCacheWrapper and SentryCacheManagerWrapper

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* collection: Cache Tracing

* fix(cache): Fix span description, putIfAbsent, and Callable hit detection

- Use cache key as span description instead of cache name, matching
  the spec and other SDKs (Python, JavaScript)
- Skip instrumentation for putIfAbsent since we cannot know if a write
  actually occurred; override to bypass default get()+put() delegation
- Wrap valueLoader Callable in get(key, Callable) to detect cache
  hit/miss instead of always reporting hit=true
- Update tests to match new behavior

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(core): [Cache Tracing 2] Add enableCacheTracing option

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(spring): [Cache Tracing 3] Add BeanPostProcessor and auto-configuration

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* fix: Update changelog PR references

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(samples): [Cache Tracing 4] Add cache tracing e2e sample

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref(samples): Replace ConcurrentMapCacheManager with Caffeine

Use Caffeine as the cache provider instead of a plain
ConcurrentMapCacheManager. Spring Boot auto-configures
CaffeineCacheManager when Caffeine is on the classpath,
so the explicit CacheManager bean is no longer needed.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix dependencies; move to toml

* feat(jcache): Add SentryJCacheWrapper for JCache (JSR-107) cache tracing

* changelog

* fix(jcache): Make replace and getAndReplace passthrough (no span)

Like putIfAbsent, these are conditional writes that may be no-ops.
Emitting a cache.put span for them would be misleading.

* fix(jcache): Check for NoOp span after startChild

startChild can return a NoOp span (e.g. when span limit is reached).
Skip instrumentation in that case to avoid unnecessary work.

* fix(jcache): Use cache.flush for removeAll() without keys

removeAll() with no args removes all entries, which is semantically
equivalent to clear(). Use cache.flush instead of cache.remove.
The keyed removeAll(Set) remains cache.remove.

* feat(samples): Add JCache cache tracing demo to console sample

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(core): Use correct cache span op terminology in Javadoc

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* fix(spring7): Avoid double-wrapping caches in SentryCacheManagerWrapper

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(samples): Add cache tracing to all Spring Boot 4 samples

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(test): Add SENTRY_ENABLE_CACHE_TRACING env var to system test runner

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(jcache): Add SentryJCacheWrapper ctor that uses ScopesAdapter

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(spring7): Add retrieve() overrides to SentryCacheWrapper

Adds support for Spring 6.1+ async cache operations (CompletableFuture
and Mono/Flux). Without these overrides, @Cacheable on reactive return
types crashes with UnsupportedOperationException.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(spring-jakarta): Add cache tracing for Spring Boot 3 / Spring 6

Port cache tracing classes from sentry-spring-7 to sentry-spring-jakarta,
covering Spring Boot 3 (Spring Framework 6.x) users. Includes
SentryCacheWrapper, SentryCacheManagerWrapper, SentryCacheBeanPostProcessor,
and auto-configuration in sentry-spring-boot-jakarta.

The retrieve() overrides for CompletableFuture/reactive cache operations
are included and safe on Spring 6.0 (where retrieve() doesn't exist on
the Cache interface) — they're simply dead code, never called by the
framework until Spring 6.1+.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(samples): Add cache tracing to all Spring Boot 3 Jakarta samples

Add CacheController, TodoService with @Cacheable/@CachePut/@CacheEvict,
Caffeine cache config, and CacheSystemTest e2e tests to all four Jakarta
sample modules:
- sentry-samples-spring-boot-jakarta
- sentry-samples-spring-boot-jakarta-opentelemetry
- sentry-samples-spring-boot-jakarta-opentelemetry-noagent
- sentry-samples-spring-boot-webflux-jakarta

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(spring): Add cache tracing for Spring Boot 2 / Spring 5

Port cache tracing instrumentation from sentry-spring-jakarta to
sentry-spring for Spring Boot 2 users. Adds SentryCacheWrapper,
SentryCacheManagerWrapper, and SentryCacheBeanPostProcessor in the
io.sentry.spring.cache package. Wires auto-configuration in
sentry-spring-boot via sentry.enable-cache-tracing=true property.

The retrieve() methods are omitted since Spring 5 does not have them
(they were added in Spring 6.1).

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(samples): Add cache tracing to Spring Boot 2 sample

Add CacheController, TodoService with @Cacheable/@CachePut/@CacheEvict
annotations, and CacheSystemTest e2e tests to the sentry-samples-spring-boot
sample. Enables cache tracing with Caffeine as the cache provider.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* fix(spring): Skip cache span data when child span is NoOp

Add span.isNoOp() check after startChild() in all three Spring
SentryCacheWrapper variants, matching the existing pattern in
SentryJCacheWrapper. This avoids setting span data on noop spans
when sampling drops the span.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(spring): Add db.operation.name attribute to cache spans

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* feat(spring): Instrument putIfAbsent, replace, and getAndReplace cache operations

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(spring): Use ValueWrapper to determine cache hit in typed get

The get(key, type) method incorrectly used result != null to detect
cache hits, failing to distinguish a miss from a cached null value.
Now uses delegate.get(key) to check the ValueWrapper first.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* docs(jcache): Fix docs link in README

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* ref(spring): Use method-specific span operations for cache spans

Instead of the 4 generic categories (cache.get, cache.put,
cache.remove, cache.flush), use the actual method name as the span
operation (e.g. cache.evict, cache.putIfAbsent, cache.retrieve).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* ref(spring): Derive span operation from operationName in startSpan

Remove redundant first parameter since it was always "cache." +
operationName. The prefix is now applied inside the helper method.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* ref(jcache): Merge startSpanForKeys into startSpan overload

Replace the separate startSpanForKeys helper with a startSpan(Set, String)
overload, unifying the two span creation methods under the same name.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Format code

* ref(cache): Move operation attribute to SpanDataConvention as CACHE_OPERATION_KEY

Replace local OPERATION_ATTRIBUTE constants in all cache wrappers with
a shared CACHE_OPERATION_KEY constant in SpanDataConvention. Also
changes the attribute key from "db.operation.name" to "cache.operation".

* feat(cache): Add cache.write boolean span attribute

Set cache.write on spans across all four cache wrapper implementations
to indicate whether an operation actually modified the cache. This
complements the existing cache.hit attribute for read operations.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(jcache): Use comma-joined keys as span description for bulk operations

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* ref(cache): Remove _KEY suffix from cache SpanDataConvention constants

Rename CACHE_HIT_KEY, CACHE_KEY_KEY, and CACHE_OPERATION_KEY to
CACHE_HIT, CACHE_KEY, and CACHE_OPERATION to match the newer naming
convention used by CACHE_WRITE, THREAD_ID, FRAMES_TOTAL, etc.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring): Fix get(key, type) double-call in SentryCacheWrapper

Use a single delegate.get(key, type) call instead of calling
delegate.get(key) for hit detection and delegate.get(key, type) for
the actual value. This eliminates doubled cache round trips (e.g. Redis
network calls) and a TOCTOU race where the entry could expire between
the two calls.

The trade-off is that cached null values are now indistinguishable from
cache misses, which is acceptable for observability purposes.

* fix(samples): Fix cache evict system test to match actual span op

* assert multiple keys in single assertions

* Format code

* update PR links in changelog

* fix(spring): [Cache Tracing 24] Track invalidate cache.write accurately

Set cache.write based on delegate.invalidate() result instead of always true.
This keeps span data aligned with Spring's invalidate semantics when no
entries were present.

Add tests in spring, spring-jakarta, and spring-7 wrappers to cover the
false return path and assert cache.write is false.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |   6 +
 README.md                                     |   1 +
 buildSrc/src/main/java/Config.kt              |   1 +
 gradle/libs.versions.toml                     |   6 +
 sentry-jcache/README.md                       |  13 +
 sentry-jcache/api/sentry-jcache.api           |  38 ++
 sentry-jcache/build.gradle.kts                |  90 +++
 .../io/sentry/jcache/SentryJCacheWrapper.java | 506 +++++++++++++++++
 .../sentry/jcache/SentryJCacheWrapperTest.kt  | 534 ++++++++++++++++++
 .../sentry-samples-console/build.gradle.kts   |   3 +
 .../java/io/sentry/samples/console/Main.java  |  50 ++
 .../build.gradle.kts                          |   4 +
 .../samples/spring/boot4/CacheController.java |  34 ++
 .../spring/boot4/SentryDemoApplication.java   |   2 +
 .../samples/spring/boot4/TodoService.java     |  29 +
 .../src/main/resources/application.properties |   3 +
 .../io/sentry/systemtest/CacheSystemTest.kt   |  51 ++
 .../build.gradle.kts                          |   4 +
 .../spring/boot4/otlp/CacheController.java    |  34 ++
 .../boot4/otlp/SentryDemoApplication.java     |   2 +
 .../spring/boot4/otlp/TodoService.java        |  29 +
 .../src/main/resources/application.properties |   3 +
 .../io/sentry/systemtest/CacheSystemTest.kt   |  51 ++
 .../build.gradle.kts                          |   4 +
 .../samples/spring/boot4/CacheController.java |  34 ++
 .../spring/boot4/SentryDemoApplication.java   |   2 +
 .../samples/spring/boot4/TodoService.java     |  29 +
 .../src/main/resources/application.properties |   3 +
 .../io/sentry/systemtest/CacheSystemTest.kt   |  51 ++
 .../build.gradle.kts                          |   4 +
 .../samples/spring/boot4/CacheController.java |  34 ++
 .../spring/boot4/SentryDemoApplication.java   |   2 +
 .../samples/spring/boot4/TodoService.java     |  29 +
 .../src/main/resources/application.properties |   3 +
 .../io/sentry/systemtest/CacheSystemTest.kt   |  51 ++
 .../build.gradle.kts                          |   4 +
 .../spring/boot/jakarta/CacheController.java  |  34 ++
 .../boot/jakarta/SentryDemoApplication.java   |   2 +
 .../spring/boot/jakarta/TodoService.java      |  29 +
 .../src/main/resources/application.properties |   5 +
 .../io/sentry/systemtest/CacheSystemTest.kt   |  51 ++
 .../build.gradle.kts                          |   4 +
 .../spring/boot/jakarta/CacheController.java  |  34 ++
 .../boot/jakarta/SentryDemoApplication.java   |   2 +
 .../spring/boot/jakarta/TodoService.java      |  29 +
 .../src/main/resources/application.properties |   5 +
 .../io/sentry/systemtest/CacheSystemTest.kt   |  51 ++
 .../build.gradle.kts                          |   4 +
 .../spring/boot/jakarta/CacheController.java  |  34 ++
 .../boot/jakarta/SentryDemoApplication.java   |   2 +
 .../spring/boot/jakarta/TodoService.java      |  29 +
 .../src/main/resources/application.properties |   5 +
 .../io/sentry/systemtest/CacheSystemTest.kt   |  51 ++
 .../build.gradle.kts                          |   4 +
 .../spring/boot/jakarta/CacheController.java  |  34 ++
 .../boot/jakarta/SentryDemoApplication.java   |   2 +
 .../spring/boot/jakarta/TodoService.java      |  29 +
 .../src/main/resources/application.properties |   5 +
 .../io/sentry/systemtest/CacheSystemTest.kt   |  51 ++
 .../build.gradle.kts                          |   2 +
 .../samples/spring/boot/CacheController.java  |  34 ++
 .../spring/boot/SentryDemoApplication.java    |   2 +
 .../samples/spring/boot/TodoService.java      |  29 +
 .../src/main/resources/application.properties |   5 +
 .../io/sentry/systemtest/CacheSystemTest.kt   |  51 ++
 sentry-spring-7/api/sentry-spring-7.api       |  29 +
 .../cache/SentryCacheBeanPostProcessor.java   |  29 +
 .../cache/SentryCacheManagerWrapper.java      |  37 ++
 .../spring7/cache/SentryCacheWrapper.java     | 326 +++++++++++
 .../cache/SentryCacheBeanPostProcessorTest.kt |  44 ++
 .../cache/SentryCacheManagerWrapperTest.kt    |  61 ++
 .../spring7/cache/SentryCacheWrapperTest.kt   | 530 +++++++++++++++++
 .../spring/boot4/SentryAutoConfiguration.java |  15 +
 .../boot4/SentryAutoConfigurationTest.kt      |  30 +
 .../boot/jakarta/SentryAutoConfiguration.java |  15 +
 .../spring/boot/SentryAutoConfiguration.java  |  15 +
 .../api/sentry-spring-jakarta.api             |  29 +
 .../cache/SentryCacheBeanPostProcessor.java   |  29 +
 .../cache/SentryCacheManagerWrapper.java      |  37 ++
 .../jakarta/cache/SentryCacheWrapper.java     | 326 +++++++++++
 .../cache/SentryCacheBeanPostProcessorTest.kt |  44 ++
 .../cache/SentryCacheManagerWrapperTest.kt    |  61 ++
 .../jakarta/cache/SentryCacheWrapperTest.kt   | 530 +++++++++++++++++
 sentry-spring/api/sentry-spring.api           |  27 +
 .../cache/SentryCacheBeanPostProcessor.java   |  29 +
 .../cache/SentryCacheManagerWrapper.java      |  37 ++
 .../spring/cache/SentryCacheWrapper.java      | 253 +++++++++
 .../cache/SentryCacheBeanPostProcessorTest.kt |  44 ++
 .../cache/SentryCacheManagerWrapperTest.kt    |  61 ++
 .../spring/cache/SentryCacheWrapperTest.kt    | 354 ++++++++++++
 .../api/sentry-system-test-support.api        |   3 +
 .../sentry/systemtest/util/RestTestClient.kt  |  18 +
 sentry/api/sentry.api                         |   8 +
 .../main/java/io/sentry/ExternalOptions.java  |  11 +
 .../main/java/io/sentry/SentryOptions.java    |  24 +
 .../java/io/sentry/SpanDataConvention.java    |   4 +
 .../java/io/sentry/ExternalOptionsTest.kt     |  14 +
 .../test/java/io/sentry/SentryOptionsTest.kt  |   7 +
 settings.gradle.kts                           |   1 +
 test/system-test-runner.py                    |   3 +-
 100 files changed, 5447 insertions(+), 1 deletion(-)
 create mode 100644 sentry-jcache/README.md
 create mode 100644 sentry-jcache/api/sentry-jcache.api
 create mode 100644 sentry-jcache/build.gradle.kts
 create mode 100644 sentry-jcache/src/main/java/io/sentry/jcache/SentryJCacheWrapper.java
 create mode 100644 sentry-jcache/src/test/kotlin/io/sentry/jcache/SentryJCacheWrapperTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/CacheController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/TodoService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CacheController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/TodoService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/CacheController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/TodoService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/CacheController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/TodoService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/CacheController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/TodoService.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
 create mode 100644 sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheBeanPostProcessor.java
 create mode 100644 sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheManagerWrapper.java
 create mode 100644 sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheWrapper.java
 create mode 100644 sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheBeanPostProcessorTest.kt
 create mode 100644 sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheManagerWrapperTest.kt
 create mode 100644 sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheWrapperTest.kt
 create mode 100644 sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheBeanPostProcessor.java
 create mode 100644 sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheManagerWrapper.java
 create mode 100644 sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheWrapper.java
 create mode 100644 sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheBeanPostProcessorTest.kt
 create mode 100644 sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheManagerWrapperTest.kt
 create mode 100644 sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheWrapperTest.kt
 create mode 100644 sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheBeanPostProcessor.java
 create mode 100644 sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheManagerWrapper.java
 create mode 100644 sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheWrapper.java
 create mode 100644 sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheBeanPostProcessorTest.kt
 create mode 100644 sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheManagerWrapperTest.kt
 create mode 100644 sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheWrapperTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 65b59334d90..fabd81c5746 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,12 @@
 
 ### Features
 
+- Add cache tracing instrumentation for Spring Boot 2, 3, and 4 ([#5165](https://github.com/getsentry/sentry-java/pull/5165))
+  - Wraps Spring `CacheManager` and `Cache` beans to produce cache spans
+  - Set `sentry.enable-cache-tracing` to `true` to enable this feature
+- Add JCache (JSR-107) cache tracing via new `sentry-jcache` module ([#5165](https://github.com/getsentry/sentry-java/pull/5165))
+  - Wraps JCache `Cache` with `SentryJCacheWrapper` to produce cache spans
+  - Set the `enableCacheTracing` option to `true` to enable this feature
 - Add configurable `IScopesStorageFactory` to `SentryOptions` for providing a custom `IScopesStorage`, e.g. when the default `ThreadLocal`-backed storage is incompatible with non-pinning thread models ([#5199](https://github.com/getsentry/sentry-java/pull/5199))
 - Android: Add `beforeErrorSampling` callback to Session Replay ([#5214](https://github.com/getsentry/sentry-java/pull/5214))
   - Allows filtering which errors trigger replay capture before the `onErrorSampleRate` is checked
diff --git a/README.md b/README.md
index 31285e2be29..25fedc8217f 100644
--- a/README.md
+++ b/README.md
@@ -57,6 +57,7 @@ Sentry SDK for Java and Android
 | sentry-graphql                          | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-graphql?style=for-the-badge&logo=sentry&color=green)                          |
 | sentry-graphql-core                     | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-graphql-core?style=for-the-badge&logo=sentry&color=green)                     |
 | sentry-graphql-22                       | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-graphql-22?style=for-the-badge&logo=sentry&color=green)                       |
+| sentry-jcache                           | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-jcache?style=for-the-badge&logo=sentry&color=green)                           |
 | sentry-quartz                           | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-quartz?style=for-the-badge&logo=sentry&color=green)                           |
 | sentry-openfeign                        | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-openfeign?style=for-the-badge&logo=sentry&color=green)                        |
 | sentry-openfeature                      | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-openfeature?style=for-the-badge&logo=sentry&color=green)                      |
diff --git a/buildSrc/src/main/java/Config.kt b/buildSrc/src/main/java/Config.kt
index 72892df5a9a..b5d1dafeb74 100644
--- a/buildSrc/src/main/java/Config.kt
+++ b/buildSrc/src/main/java/Config.kt
@@ -77,6 +77,7 @@ object Config {
         val SENTRY_GRAPHQL_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.graphql"
         val SENTRY_GRAPHQL_CORE_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.graphql-core"
         val SENTRY_GRAPHQL22_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.graphql22"
+        val SENTRY_JCACHE_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.jcache"
         val SENTRY_QUARTZ_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.quartz"
         val SENTRY_JDBC_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.jdbc"
         val SENTRY_OPENFEATURE_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.openfeature"
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 60be4fd2c03..eb7ab86e4bd 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -99,6 +99,8 @@ androidx-recyclerview = { module = "androidx.recyclerview:recyclerview", version
 androidx-browser = { module = "androidx.browser:browser", version = "1.8.0" }
 async-profiler = { module = "tools.profiler:async-profiler", version.ref = "asyncProfiler" }
 async-profiler-jfr-converter = { module = "tools.profiler:jfr-converter", version.ref = "asyncProfiler" }
+caffeine = { module = "com.github.ben-manes.caffeine:caffeine" }
+caffeine-jcache = { module = "com.github.ben-manes.caffeine:jcache", version = "3.2.0" }
 coil-compose = { module = "io.coil-kt:coil-compose", version = "2.6.0" }
 commons-compress = {module = "org.apache.commons:commons-compress", version = "1.25.0"}
 context-propagation = { module = "io.micrometer:context-propagation", version = "1.1.0" }
@@ -144,6 +146,7 @@ otel-semconv = { module = "io.opentelemetry.semconv:opentelemetry-semconv", vers
 otel-semconv-incubating = { module = "io.opentelemetry.semconv:opentelemetry-semconv-incubating", version.ref = "otelSemanticConventionsAlpha" }
 p6spy = { module = "p6spy:p6spy", version = "3.9.1" }
 epitaph = { module = "com.abovevacant:epitaph", version = "0.1.1" }
+jcache = { module = "javax.cache:cache-api", version = "1.1.1" }
 quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
@@ -166,6 +169,7 @@ springboot-starter-aop = { module = "org.springframework.boot:spring-boot-starte
 springboot-starter-security = { module = "org.springframework.boot:spring-boot-starter-security", version.ref = "springboot2" }
 springboot-starter-jdbc = { module = "org.springframework.boot:spring-boot-starter-jdbc", version.ref = "springboot2" }
 springboot-starter-actuator = { module = "org.springframework.boot:spring-boot-starter-actuator", version.ref = "springboot2" }
+springboot-starter-cache = { module = "org.springframework.boot:spring-boot-starter-cache", version.ref = "springboot2" }
 springboot3-otel = { module = "io.opentelemetry.instrumentation:opentelemetry-spring-boot-starter", version.ref = "otelInstrumentation" }
 springboot3-starter = { module = "org.springframework.boot:spring-boot-starter", version.ref = "springboot3" }
 springboot3-starter-graphql = { module = "org.springframework.boot:spring-boot-starter-graphql", version.ref = "springboot3" }
@@ -178,6 +182,7 @@ springboot3-starter-aop = { module = "org.springframework.boot:spring-boot-start
 springboot3-starter-security = { module = "org.springframework.boot:spring-boot-starter-security", version.ref = "springboot3" }
 springboot3-starter-jdbc = { module = "org.springframework.boot:spring-boot-starter-jdbc", version.ref = "springboot3" }
 springboot3-starter-actuator = { module = "org.springframework.boot:spring-boot-starter-actuator", version.ref = "springboot3" }
+springboot3-starter-cache = { module = "org.springframework.boot:spring-boot-starter-cache", version.ref = "springboot3" }
 springboot4-otel = { module = "io.opentelemetry.instrumentation:opentelemetry-spring-boot-starter", version.ref = "otelInstrumentation" }
 springboot4-resttestclient = { module = "org.springframework.boot:spring-boot-resttestclient", version.ref = "springboot4" }
 springboot4-starter = { module = "org.springframework.boot:spring-boot-starter", version.ref = "springboot4" }
@@ -193,6 +198,7 @@ springboot4-starter-restclient = { module = "org.springframework.boot:spring-boo
 springboot4-starter-webclient = { module = "org.springframework.boot:spring-boot-starter-webclient", version.ref = "springboot4" }
 springboot4-starter-jdbc = { module = "org.springframework.boot:spring-boot-starter-jdbc", version.ref = "springboot4" }
 springboot4-starter-actuator = { module = "org.springframework.boot:spring-boot-starter-actuator", version.ref = "springboot4" }
+springboot4-starter-cache = { module = "org.springframework.boot:spring-boot-starter-cache", version.ref = "springboot4" }
 timber = { module = "com.jakewharton.timber:timber", version = "4.7.1" }
 
 # Animalsniffer signature
diff --git a/sentry-jcache/README.md b/sentry-jcache/README.md
new file mode 100644
index 00000000000..e4f4d8e49a4
--- /dev/null
+++ b/sentry-jcache/README.md
@@ -0,0 +1,13 @@
+# sentry-jcache
+
+This module provides an integration for JCache (JSR-107).
+
+JCache is a standard API — you need a provider implementation at runtime. Common implementations include:
+
+- [Caffeine](https://github.com/ben-manes/caffeine) (via `com.github.ben-manes.caffeine:jcache`)
+- [Ehcache 3](https://www.ehcache.org/) (via `org.ehcache:ehcache`)
+- [Hazelcast](https://hazelcast.com/)
+- [Apache Ignite](https://ignite.apache.org/)
+- [Infinispan](https://infinispan.org/)
+
+Please consult the documentation on how to install and use this integration in the Sentry Docs for [Java](https://docs.sentry.io/platforms/java/integrations/jcache/).
diff --git a/sentry-jcache/api/sentry-jcache.api b/sentry-jcache/api/sentry-jcache.api
new file mode 100644
index 00000000000..b834ba41064
--- /dev/null
+++ b/sentry-jcache/api/sentry-jcache.api
@@ -0,0 +1,38 @@
+public final class io/sentry/jcache/BuildConfig {
+	public static final field SENTRY_JCACHE_SDK_NAME Ljava/lang/String;
+	public static final field VERSION_NAME Ljava/lang/String;
+}
+
+public final class io/sentry/jcache/SentryJCacheWrapper : javax/cache/Cache {
+	public fun <init> (Ljavax/cache/Cache;)V
+	public fun <init> (Ljavax/cache/Cache;Lio/sentry/IScopes;)V
+	public fun clear ()V
+	public fun close ()V
+	public fun containsKey (Ljava/lang/Object;)Z
+	public fun deregisterCacheEntryListener (Ljavax/cache/configuration/CacheEntryListenerConfiguration;)V
+	public fun get (Ljava/lang/Object;)Ljava/lang/Object;
+	public fun getAll (Ljava/util/Set;)Ljava/util/Map;
+	public fun getAndPut (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun getAndRemove (Ljava/lang/Object;)Ljava/lang/Object;
+	public fun getAndReplace (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
+	public fun getCacheManager ()Ljavax/cache/CacheManager;
+	public fun getConfiguration (Ljava/lang/Class;)Ljavax/cache/configuration/Configuration;
+	public fun getName ()Ljava/lang/String;
+	public fun invoke (Ljava/lang/Object;Ljavax/cache/processor/EntryProcessor;[Ljava/lang/Object;)Ljava/lang/Object;
+	public fun invokeAll (Ljava/util/Set;Ljavax/cache/processor/EntryProcessor;[Ljava/lang/Object;)Ljava/util/Map;
+	public fun isClosed ()Z
+	public fun iterator ()Ljava/util/Iterator;
+	public fun loadAll (Ljava/util/Set;ZLjavax/cache/integration/CompletionListener;)V
+	public fun put (Ljava/lang/Object;Ljava/lang/Object;)V
+	public fun putAll (Ljava/util/Map;)V
+	public fun putIfAbsent (Ljava/lang/Object;Ljava/lang/Object;)Z
+	public fun registerCacheEntryListener (Ljavax/cache/configuration/CacheEntryListenerConfiguration;)V
+	public fun remove (Ljava/lang/Object;)Z
+	public fun remove (Ljava/lang/Object;Ljava/lang/Object;)Z
+	public fun removeAll ()V
+	public fun removeAll (Ljava/util/Set;)V
+	public fun replace (Ljava/lang/Object;Ljava/lang/Object;)Z
+	public fun replace (Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z
+	public fun unwrap (Ljava/lang/Class;)Ljava/lang/Object;
+}
+
diff --git a/sentry-jcache/build.gradle.kts b/sentry-jcache/build.gradle.kts
new file mode 100644
index 00000000000..a9393a7d905
--- /dev/null
+++ b/sentry-jcache/build.gradle.kts
@@ -0,0 +1,90 @@
+import net.ltgt.gradle.errorprone.errorprone
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  `java-library`
+  id("io.sentry.javadoc")
+  alias(libs.plugins.kotlin.jvm)
+  jacoco
+  alias(libs.plugins.errorprone)
+  alias(libs.plugins.gradle.versions)
+  alias(libs.plugins.buildconfig)
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
+  compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+  compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+}
+
+dependencies {
+  api(projects.sentry)
+  compileOnly(libs.jcache)
+
+  compileOnly(libs.jetbrains.annotations)
+  compileOnly(libs.nopen.annotations)
+  errorprone(libs.errorprone.core)
+  errorprone(libs.nopen.checker)
+  errorprone(libs.nullaway)
+
+  // tests
+  testImplementation(projects.sentry)
+  testImplementation(projects.sentryTestSupport)
+  testImplementation(libs.jcache)
+  testImplementation(kotlin(Config.kotlinStdLib))
+  testImplementation(libs.kotlin.test.junit)
+  testImplementation(libs.mockito.kotlin)
+  testImplementation(libs.mockito.inline)
+}
+
+configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
+
+jacoco { toolVersion = libs.versions.jacoco.get() }
+
+tasks.jacocoTestReport {
+  reports {
+    xml.required.set(true)
+    html.required.set(false)
+  }
+}
+
+tasks {
+  jacocoTestCoverageVerification {
+    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
+  }
+  check {
+    dependsOn(jacocoTestCoverageVerification)
+    dependsOn(jacocoTestReport)
+  }
+}
+
+tasks.withType<JavaCompile>().configureEach {
+  options.errorprone {
+    check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
+    option("NullAway:AnnotatedPackages", "io.sentry")
+  }
+}
+
+buildConfig {
+  useJavaOutput()
+  packageName("io.sentry.jcache")
+  buildConfigField(
+    "String",
+    "SENTRY_JCACHE_SDK_NAME",
+    "\"${Config.Sentry.SENTRY_JCACHE_SDK_NAME}\"",
+  )
+  buildConfigField("String", "VERSION_NAME", "\"${project.version}\"")
+}
+
+tasks.jar {
+  manifest {
+    attributes(
+      "Sentry-Version-Name" to project.version,
+      "Sentry-SDK-Name" to Config.Sentry.SENTRY_JCACHE_SDK_NAME,
+      "Sentry-SDK-Package-Name" to "maven:io.sentry:sentry-jcache",
+      "Implementation-Vendor" to "Sentry",
+      "Implementation-Title" to project.name,
+      "Implementation-Version" to project.version,
+    )
+  }
+}
diff --git a/sentry-jcache/src/main/java/io/sentry/jcache/SentryJCacheWrapper.java b/sentry-jcache/src/main/java/io/sentry/jcache/SentryJCacheWrapper.java
new file mode 100644
index 00000000000..e1c3b786e85
--- /dev/null
+++ b/sentry-jcache/src/main/java/io/sentry/jcache/SentryJCacheWrapper.java
@@ -0,0 +1,506 @@
+package io.sentry.jcache;
+
+import io.sentry.IScopes;
+import io.sentry.ISpan;
+import io.sentry.ScopesAdapter;
+import io.sentry.SpanDataConvention;
+import io.sentry.SpanOptions;
+import io.sentry.SpanStatus;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.cache.Cache;
+import javax.cache.CacheManager;
+import javax.cache.configuration.CacheEntryListenerConfiguration;
+import javax.cache.configuration.Configuration;
+import javax.cache.integration.CompletionListener;
+import javax.cache.processor.EntryProcessor;
+import javax.cache.processor.EntryProcessorException;
+import javax.cache.processor.EntryProcessorResult;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Wraps a JCache {@link Cache} to create Sentry spans for cache operations.
+ *
+ * @param <K> the type of key
+ * @param <V> the type of value
+ */
+@ApiStatus.Experimental
+public final class SentryJCacheWrapper<K, V> implements Cache<K, V> {
+
+  private static final String TRACE_ORIGIN = "auto.cache.jcache";
+
+  private final @NotNull Cache<K, V> delegate;
+  private final @NotNull IScopes scopes;
+
+  public SentryJCacheWrapper(final @NotNull Cache<K, V> delegate) {
+    this(delegate, ScopesAdapter.getInstance());
+  }
+
+  public SentryJCacheWrapper(final @NotNull Cache<K, V> delegate, final @NotNull IScopes scopes) {
+    this.delegate = delegate;
+    this.scopes = scopes;
+  }
+
+  // -- read operations --
+
+  @Override
+  public V get(final K key) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key);
+    }
+    try {
+      final V result = delegate.get(key);
+      span.setData(SpanDataConvention.CACHE_HIT, result != null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public Map<K, V> getAll(final Set<? extends K> keys) {
+    final ISpan span = startSpanForKeys(keys, "getAll");
+    if (span == null) {
+      return delegate.getAll(keys);
+    }
+    try {
+      final Map<K, V> result = delegate.getAll(keys);
+      span.setData(SpanDataConvention.CACHE_HIT, !result.isEmpty());
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean containsKey(final K key) {
+    return delegate.containsKey(key);
+  }
+
+  // -- write operations --
+
+  @Override
+  public void put(final K key, final V value) {
+    final ISpan span = startSpan(key, "put");
+    if (span == null) {
+      delegate.put(key, value);
+      return;
+    }
+    try {
+      delegate.put(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public V getAndPut(final K key, final V value) {
+    final ISpan span = startSpan(key, "getAndPut");
+    if (span == null) {
+      return delegate.getAndPut(key, value);
+    }
+    try {
+      final V result = delegate.getAndPut(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void putAll(final Map<? extends K, ? extends V> map) {
+    final ISpan span = startSpanForKeys(map.keySet(), "putAll");
+    if (span == null) {
+      delegate.putAll(map);
+      return;
+    }
+    try {
+      delegate.putAll(map);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean putIfAbsent(final K key, final V value) {
+    final ISpan span = startSpan(key, "putIfAbsent");
+    if (span == null) {
+      return delegate.putIfAbsent(key, value);
+    }
+    try {
+      final boolean result = delegate.putIfAbsent(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean replace(final K key, final V oldValue, final V newValue) {
+    final ISpan span = startSpan(key, "replace");
+    if (span == null) {
+      return delegate.replace(key, oldValue, newValue);
+    }
+    try {
+      final boolean result = delegate.replace(key, oldValue, newValue);
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean replace(final K key, final V value) {
+    final ISpan span = startSpan(key, "replace");
+    if (span == null) {
+      return delegate.replace(key, value);
+    }
+    try {
+      final boolean result = delegate.replace(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public V getAndReplace(final K key, final V value) {
+    final ISpan span = startSpan(key, "getAndReplace");
+    if (span == null) {
+      return delegate.getAndReplace(key, value);
+    }
+    try {
+      final V result = delegate.getAndReplace(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, result != null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  // -- remove operations --
+
+  @Override
+  public boolean remove(final K key) {
+    final ISpan span = startSpan(key, "remove");
+    if (span == null) {
+      return delegate.remove(key);
+    }
+    try {
+      final boolean result = delegate.remove(key);
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean remove(final K key, final V oldValue) {
+    final ISpan span = startSpan(key, "remove");
+    if (span == null) {
+      return delegate.remove(key, oldValue);
+    }
+    try {
+      final boolean result = delegate.remove(key, oldValue);
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public V getAndRemove(final K key) {
+    final ISpan span = startSpan(key, "getAndRemove");
+    if (span == null) {
+      return delegate.getAndRemove(key);
+    }
+    try {
+      final V result = delegate.getAndRemove(key);
+      span.setData(SpanDataConvention.CACHE_WRITE, result != null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void removeAll(final Set<? extends K> keys) {
+    final ISpan span = startSpanForKeys(keys, "removeAll");
+    if (span == null) {
+      delegate.removeAll(keys);
+      return;
+    }
+    try {
+      delegate.removeAll(keys);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void removeAll() {
+    final ISpan span = startSpan(null, "removeAll");
+    if (span == null) {
+      delegate.removeAll();
+      return;
+    }
+    try {
+      delegate.removeAll();
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  // -- flush operations --
+
+  @Override
+  public void clear() {
+    final ISpan span = startSpan(null, "clear");
+    if (span == null) {
+      delegate.clear();
+      return;
+    }
+    try {
+      delegate.clear();
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void close() {
+    delegate.close();
+  }
+
+  // -- entry processor operations --
+
+  @Override
+  public <T> T invoke(
+      final K key, final EntryProcessor<K, V, T> entryProcessor, final Object... arguments)
+      throws EntryProcessorException {
+    final ISpan span = startSpan(key, "invoke");
+    if (span == null) {
+      return delegate.invoke(key, entryProcessor, arguments);
+    }
+    try {
+      final T result = delegate.invoke(key, entryProcessor, arguments);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public <T> Map<K, EntryProcessorResult<T>> invokeAll(
+      final Set<? extends K> keys,
+      final EntryProcessor<K, V, T> entryProcessor,
+      final Object... arguments) {
+    final ISpan span = startSpanForKeys(keys, "invokeAll");
+    if (span == null) {
+      return delegate.invokeAll(keys, entryProcessor, arguments);
+    }
+    try {
+      final Map<K, EntryProcessorResult<T>> result =
+          delegate.invokeAll(keys, entryProcessor, arguments);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  // -- passthrough operations --
+
+  @Override
+  public void loadAll(
+      final Set<? extends K> keys,
+      final boolean replaceExistingValues,
+      final CompletionListener completionListener) {
+    delegate.loadAll(keys, replaceExistingValues, completionListener);
+  }
+
+  @Override
+  public String getName() {
+    return delegate.getName();
+  }
+
+  @Override
+  public CacheManager getCacheManager() {
+    return delegate.getCacheManager();
+  }
+
+  @Override
+  public <C extends Configuration<K, V>> C getConfiguration(final Class<C> clazz) {
+    return delegate.getConfiguration(clazz);
+  }
+
+  @Override
+  public boolean isClosed() {
+    return delegate.isClosed();
+  }
+
+  @Override
+  public <T> T unwrap(final Class<T> clazz) {
+    return delegate.unwrap(clazz);
+  }
+
+  @Override
+  public void registerCacheEntryListener(
+      final CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) {
+    delegate.registerCacheEntryListener(cacheEntryListenerConfiguration);
+  }
+
+  @Override
+  public void deregisterCacheEntryListener(
+      final CacheEntryListenerConfiguration<K, V> cacheEntryListenerConfiguration) {
+    delegate.deregisterCacheEntryListener(cacheEntryListenerConfiguration);
+  }
+
+  @Override
+  public Iterator<Entry<K, V>> iterator() {
+    return delegate.iterator();
+  }
+
+  // -- span helpers --
+
+  private @Nullable ISpan startSpan(
+      final @Nullable Object key, final @NotNull String operationName) {
+    final String keyString = key != null ? String.valueOf(key) : null;
+    return startSpan(
+        operationName, keyString, keyString != null ? Collections.singletonList(keyString) : null);
+  }
+
+  private @Nullable ISpan startSpanForKeys(
+      final @NotNull Set<?> keys, final @NotNull String operationName) {
+    final List<String> keyStrings = keys.stream().map(String::valueOf).collect(Collectors.toList());
+    return startSpan(operationName, String.join(", ", keyStrings), keyStrings);
+  }
+
+  private @Nullable ISpan startSpan(
+      final @NotNull String operationName,
+      final @Nullable String description,
+      final @Nullable List<String> cacheKeys) {
+    if (!scopes.getOptions().isEnableCacheTracing()) {
+      return null;
+    }
+
+    final ISpan activeSpan = scopes.getSpan();
+    if (activeSpan == null || activeSpan.isNoOp()) {
+      return null;
+    }
+
+    final SpanOptions spanOptions = new SpanOptions();
+    spanOptions.setOrigin(TRACE_ORIGIN);
+    final ISpan span = activeSpan.startChild("cache." + operationName, description, spanOptions);
+    if (span.isNoOp()) {
+      return null;
+    }
+    if (cacheKeys != null) {
+      span.setData(SpanDataConvention.CACHE_KEY, cacheKeys);
+    }
+    span.setData(SpanDataConvention.CACHE_OPERATION, operationName);
+    return span;
+  }
+}
diff --git a/sentry-jcache/src/test/kotlin/io/sentry/jcache/SentryJCacheWrapperTest.kt b/sentry-jcache/src/test/kotlin/io/sentry/jcache/SentryJCacheWrapperTest.kt
new file mode 100644
index 00000000000..9e523d3df21
--- /dev/null
+++ b/sentry-jcache/src/test/kotlin/io/sentry/jcache/SentryJCacheWrapperTest.kt
@@ -0,0 +1,534 @@
+package io.sentry.jcache
+
+import io.sentry.IScopes
+import io.sentry.SentryOptions
+import io.sentry.SentryTracer
+import io.sentry.SpanDataConvention
+import io.sentry.SpanStatus
+import io.sentry.TransactionContext
+import javax.cache.Cache
+import javax.cache.CacheManager
+import javax.cache.configuration.CacheEntryListenerConfiguration
+import javax.cache.configuration.Configuration
+import javax.cache.integration.CompletionListener
+import javax.cache.processor.EntryProcessor
+import javax.cache.processor.EntryProcessorResult
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class SentryJCacheWrapperTest {
+
+  private lateinit var scopes: IScopes
+  private lateinit var delegate: Cache<String, String>
+  private lateinit var options: SentryOptions
+
+  @BeforeTest
+  fun setup() {
+    scopes = mock()
+    delegate = mock()
+    options = SentryOptions().apply { isEnableCacheTracing = true }
+    whenever(scopes.options).thenReturn(options)
+    whenever(delegate.name).thenReturn("testCache")
+  }
+
+  private fun createTransaction(): SentryTracer {
+    val tx = SentryTracer(TransactionContext("tx", "op"), scopes)
+    whenever(scopes.span).thenReturn(tx)
+    return tx
+  }
+
+  // -- get(K key) --
+
+  @Test
+  fun `get creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn("value")
+
+    val result = wrapper.get("myKey")
+
+    assertEquals("value", result)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.get", span.operation)
+    assertEquals("myKey", span.description)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_HIT))
+    assertNull(span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("auto.cache.jcache", span.spanContext.origin)
+    assertEquals("get", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  @Test
+  fun `get creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    val result = wrapper.get("myKey")
+
+    assertNull(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+  }
+
+  // -- getAll --
+
+  @Test
+  fun `getAll creates span with cache hit true when results exist`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val keys = setOf("k1", "k2")
+    whenever(delegate.getAll(keys)).thenReturn(mapOf("k1" to "v1"))
+
+    val result = wrapper.getAll(keys)
+
+    assertEquals(mapOf("k1" to "v1"), result)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.getAll", span.operation)
+    assertEquals("k1, k2", span.description)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("k1", "k2"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("getAll", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  @Test
+  fun `getAll creates span with cache hit false when empty`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val keys = setOf("k1")
+    whenever(delegate.getAll(keys)).thenReturn(emptyMap())
+
+    wrapper.getAll(keys)
+
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+  }
+
+  // -- put --
+
+  @Test
+  fun `put creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+
+    wrapper.put("myKey", "myValue")
+
+    verify(delegate).put("myKey", "myValue")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.put", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("put", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- getAndPut --
+
+  @Test
+  fun `getAndPut creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.getAndPut("myKey", "newValue")).thenReturn("oldValue")
+
+    val result = wrapper.getAndPut("myKey", "newValue")
+
+    assertEquals("oldValue", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.getAndPut", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("getAndPut", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- putAll --
+
+  @Test
+  fun `putAll creates cache put span with all keys`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val entries = mapOf("k1" to "v1", "k2" to "v2")
+
+    wrapper.putAll(entries)
+
+    verify(delegate).putAll(entries)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.putAll", span.operation)
+    assertEquals("k1, k2", span.description)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("k1", "k2"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("putAll", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- putIfAbsent --
+
+  @Test
+  fun `putIfAbsent creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.putIfAbsent("myKey", "myValue")).thenReturn(true)
+
+    val result = wrapper.putIfAbsent("myKey", "myValue")
+
+    assertTrue(result)
+    verify(delegate).putIfAbsent("myKey", "myValue")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.putIfAbsent", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("putIfAbsent", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- replace --
+
+  @Test
+  fun `replace with old value creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.replace("myKey", "old", "new")).thenReturn(true)
+
+    val result = wrapper.replace("myKey", "old", "new")
+
+    assertTrue(result)
+    verify(delegate).replace("myKey", "old", "new")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.replace", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("replace", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  @Test
+  fun `replace creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.replace("myKey", "value")).thenReturn(true)
+
+    val result = wrapper.replace("myKey", "value")
+
+    assertTrue(result)
+    verify(delegate).replace("myKey", "value")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.replace", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("replace", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- getAndReplace --
+
+  @Test
+  fun `getAndReplace creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.getAndReplace("myKey", "newValue")).thenReturn("oldValue")
+
+    val result = wrapper.getAndReplace("myKey", "newValue")
+
+    assertEquals("oldValue", result)
+    verify(delegate).getAndReplace("myKey", "newValue")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.getAndReplace", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("getAndReplace", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- remove(K) --
+
+  @Test
+  fun `remove creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.remove("myKey")).thenReturn(true)
+
+    val result = wrapper.remove("myKey")
+
+    assertTrue(result)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.remove", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("remove", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- remove(K, V) --
+
+  @Test
+  fun `remove with value creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.remove("myKey", "myValue")).thenReturn(true)
+
+    val result = wrapper.remove("myKey", "myValue")
+
+    assertTrue(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.remove", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("remove", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- getAndRemove --
+
+  @Test
+  fun `getAndRemove creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.getAndRemove("myKey")).thenReturn("value")
+
+    val result = wrapper.getAndRemove("myKey")
+
+    assertEquals("value", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.getAndRemove", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("getAndRemove", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- removeAll(Set) --
+
+  @Test
+  fun `removeAll with keys creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val keys = setOf("k1", "k2")
+
+    wrapper.removeAll(keys)
+
+    verify(delegate).removeAll(keys)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.removeAll", span.operation)
+    assertEquals("k1, k2", span.description)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("k1", "k2"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("removeAll", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- removeAll() --
+
+  @Test
+  fun `removeAll without keys creates cache flush span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+
+    wrapper.removeAll()
+
+    verify(delegate).removeAll()
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.removeAll", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("removeAll", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- clear --
+
+  @Test
+  fun `clear creates cache flush span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+
+    wrapper.clear()
+
+    verify(delegate).clear()
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.clear", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertNull(span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("clear", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- invoke --
+
+  @Test
+  fun `invoke creates cache get span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val processor = mock<EntryProcessor<String, String, String>>()
+    whenever(delegate.invoke("myKey", processor)).thenReturn("result")
+
+    val result = wrapper.invoke("myKey", processor)
+
+    assertEquals("result", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.invoke", tx.spans.first().operation)
+    assertEquals("invoke", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- invokeAll --
+
+  @Test
+  fun `invokeAll creates cache get span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val processor = mock<EntryProcessor<String, String, String>>()
+    val keys = setOf("k1", "k2")
+    val resultMap = mock<Map<String, EntryProcessorResult<String>>>()
+    whenever(delegate.invokeAll(keys, processor)).thenReturn(resultMap)
+
+    val result = wrapper.invokeAll(keys, processor)
+
+    assertEquals(resultMap, result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.invokeAll", tx.spans.first().operation)
+    assertEquals("invokeAll", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- passthrough operations --
+
+  @Test
+  fun `containsKey delegates without creating span`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.containsKey("myKey")).thenReturn(true)
+
+    assertTrue(wrapper.containsKey("myKey"))
+    assertEquals(0, tx.spans.size)
+  }
+
+  @Test
+  fun `getName delegates to underlying cache`() {
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    assertEquals("testCache", wrapper.name)
+  }
+
+  @Test
+  fun `getCacheManager delegates to underlying cache`() {
+    val manager = mock<CacheManager>()
+    whenever(delegate.cacheManager).thenReturn(manager)
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    assertEquals(manager, wrapper.cacheManager)
+  }
+
+  @Test
+  fun `isClosed delegates to underlying cache`() {
+    whenever(delegate.isClosed).thenReturn(false)
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    assertFalse(wrapper.isClosed)
+  }
+
+  @Test
+  fun `close delegates to underlying cache`() {
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    wrapper.close()
+    verify(delegate).close()
+  }
+
+  @Test
+  fun `registerCacheEntryListener delegates to underlying cache`() {
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val config = mock<CacheEntryListenerConfiguration<String, String>>()
+    wrapper.registerCacheEntryListener(config)
+    verify(delegate).registerCacheEntryListener(config)
+  }
+
+  @Test
+  fun `deregisterCacheEntryListener delegates to underlying cache`() {
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val config = mock<CacheEntryListenerConfiguration<String, String>>()
+    wrapper.deregisterCacheEntryListener(config)
+    verify(delegate).deregisterCacheEntryListener(config)
+  }
+
+  @Test
+  fun `iterator delegates to underlying cache`() {
+    val iter = mock<MutableIterator<Cache.Entry<String, String>>>()
+    whenever(delegate.iterator()).thenReturn(iter)
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    assertEquals(iter, wrapper.iterator())
+  }
+
+  @Test
+  fun `loadAll delegates to underlying cache`() {
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val keys = setOf("k1")
+    val listener = mock<CompletionListener>()
+    wrapper.loadAll(keys, true, listener)
+    verify(delegate).loadAll(keys, true, listener)
+  }
+
+  @Test
+  fun `getConfiguration delegates to underlying cache`() {
+    val config = mock<Configuration<String, String>>()
+    whenever(
+        delegate.getConfiguration(Configuration::class.java as Class<Configuration<String, String>>)
+      )
+      .thenReturn(config)
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    assertEquals(
+      config,
+      wrapper.getConfiguration(Configuration::class.java as Class<Configuration<String, String>>),
+    )
+  }
+
+  @Test
+  fun `unwrap delegates to underlying cache`() {
+    whenever(delegate.unwrap(String::class.java)).thenReturn("unwrapped")
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    assertEquals("unwrapped", wrapper.unwrap(String::class.java))
+  }
+
+  // -- no span when no active transaction --
+
+  @Test
+  fun `does not create span when there is no active transaction`() {
+    whenever(scopes.span).thenReturn(null)
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    wrapper.get("myKey")
+
+    verify(delegate).get("myKey")
+  }
+
+  // -- no span when option is disabled --
+
+  @Test
+  fun `does not create span when enableCacheTracing is false`() {
+    options.isEnableCacheTracing = false
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    wrapper.get("myKey")
+
+    verify(delegate).get("myKey")
+    assertEquals(0, tx.spans.size)
+  }
+
+  // -- error handling --
+
+  @Test
+  fun `sets error status and throwable on exception`() {
+    val tx = createTransaction()
+    val wrapper = SentryJCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("cache error")
+    whenever(delegate.get("myKey")).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { wrapper.get("myKey") }
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+  }
+}
diff --git a/sentry-samples/sentry-samples-console/build.gradle.kts b/sentry-samples/sentry-samples-console/build.gradle.kts
index 5737e8effe0..0dc6183b4fc 100644
--- a/sentry-samples/sentry-samples-console/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console/build.gradle.kts
@@ -35,6 +35,9 @@ tasks.withType<KotlinCompile>().configureEach {
 dependencies {
   implementation(projects.sentry)
   implementation(projects.sentryAsyncProfiler)
+  implementation(projects.sentryJcache)
+  implementation(libs.jcache)
+  implementation(libs.caffeine.jcache)
 
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(projects.sentry)
diff --git a/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java b/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java
index 29fae9381b2..0ed0646c7bc 100644
--- a/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java
+++ b/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java
@@ -2,9 +2,14 @@
 
 import io.sentry.*;
 import io.sentry.clientreport.DiscardReason;
+import io.sentry.jcache.SentryJCacheWrapper;
 import io.sentry.protocol.Message;
 import io.sentry.protocol.User;
 import java.util.Collections;
+import javax.cache.Cache;
+import javax.cache.CacheManager;
+import javax.cache.Caching;
+import javax.cache.configuration.MutableConfiguration;
 
 public class Main {
 
@@ -88,6 +93,9 @@ public static void main(String[] args) throws InterruptedException {
           // Set what percentage of traces should be collected
           options.setTracesSampleRate(1.0); // set 0.5 to send 50% of traces
 
+          // Enable cache tracing to create spans for cache operations
+          options.setEnableCacheTracing(true);
+
           // Determine traces sample rate based on the sampling context
           //          options.setTracesSampler(
           //              context -> {
@@ -164,6 +172,12 @@ public static void main(String[] args) throws InterruptedException {
       Sentry.captureEvent(event, hint);
     }
 
+    // Cache tracing with JCache (JSR-107)
+    //
+    // Wrapping a JCache Cache with SentryJCacheWrapper creates cache.get, cache.put,
+    // cache.remove, and cache.flush spans as children of the active transaction.
+    demonstrateCacheTracing();
+
     // Performance feature
     //
     // Transactions collect execution time of the piece of code that's executed between the start
@@ -191,6 +205,42 @@ public static void main(String[] args) throws InterruptedException {
     // Sentry.close();
   }
 
+  private static void demonstrateCacheTracing() {
+    // Create a JCache CacheManager and Cache using standard JSR-107 API
+    CacheManager cacheManager = Caching.getCachingProvider().getCacheManager();
+    MutableConfiguration<String, String> config =
+        new MutableConfiguration<String, String>().setTypes(String.class, String.class);
+    Cache<String, String> rawCache = cacheManager.createCache("myCache", config);
+
+    // Wrap with SentryJCacheWrapper to enable cache tracing
+    Cache<String, String> cache = new SentryJCacheWrapper<>(rawCache);
+
+    // All cache operations inside a transaction produce child spans
+    ITransaction transaction = Sentry.startTransaction("cache-demo", "demo");
+    try (ISentryLifecycleToken ignored = transaction.makeCurrent()) {
+      // cache.put span
+      cache.put("greeting", "hello");
+
+      // cache.get span (hit — returns "hello", cache.hit = true)
+      cache.get("greeting");
+
+      // cache.get span (miss — returns null, cache.hit = false)
+      cache.get("nonexistent");
+
+      // cache.remove span
+      cache.remove("greeting");
+
+      // cache.flush span
+      cache.clear();
+    } finally {
+      transaction.finish();
+    }
+
+    // Clean up
+    cacheManager.destroyCache("myCache");
+    cacheManager.close();
+  }
+
   private static void captureMetrics() {
     Sentry.metrics().count("countMetric");
     Sentry.metrics().gauge("gaugeMetric", 5.0);
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
index ef38162d6bf..c3e8ba06fae 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
@@ -59,6 +59,10 @@ dependencies {
   implementation(projects.sentryAsyncProfiler)
   implementation(libs.otel)
 
+  // cache tracing
+  implementation(libs.springboot4.starter.cache)
+  implementation(libs.caffeine)
+
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/CacheController.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/CacheController.java
new file mode 100644
index 00000000000..3c2e66442de
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/CacheController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot4;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/cache/")
+public class CacheController {
+  private final TodoService todoService;
+
+  public CacheController(TodoService todoService) {
+    this.todoService = todoService;
+  }
+
+  @GetMapping("{id}")
+  Todo get(@PathVariable Long id) {
+    return todoService.get(id);
+  }
+
+  @PostMapping
+  Todo save(@RequestBody Todo todo) {
+    return todoService.save(todo);
+  }
+
+  @DeleteMapping("{id}")
+  void delete(@PathVariable Long id) {
+    todoService.delete(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java
index aa5ebce68cd..b00609ad9ac 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java
@@ -11,6 +11,7 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.restclient.RestTemplateBuilder;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
@@ -21,6 +22,7 @@
 import org.springframework.web.reactive.function.client.WebClient;
 
 @SpringBootApplication
+@EnableCaching
 @EnableScheduling
 public class SentryDemoApplication {
   public static void main(String[] args) {
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/TodoService.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/TodoService.java
new file mode 100644
index 00000000000..c837ab8398a
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/TodoService.java
@@ -0,0 +1,29 @@
+package io.sentry.samples.spring.boot4;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TodoService {
+  private final Map<Long, Todo> store = new ConcurrentHashMap<>();
+
+  @Cacheable(value = "todos", key = "#id")
+  public Todo get(Long id) {
+    return store.get(id);
+  }
+
+  @CachePut(value = "todos", key = "#todo.id")
+  public Todo save(Todo todo) {
+    store.put(todo.getId(), todo);
+    return todo;
+  }
+
+  @CacheEvict(value = "todos", key = "#id")
+  public void delete(Long id) {
+    store.remove(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/resources/application.properties
index 6b57706019b..a0808e04fde 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/resources/application.properties
@@ -20,6 +20,9 @@ sentry.in-app-includes="io.sentry.samples"
 sentry.profile-session-sample-rate=1.0
 sentry.profiling-traces-dir-path=tmp/sentry/profiling-traces
 sentry.profile-lifecycle=TRACE
+sentry.enable-cache-tracing=true
+spring.cache.cache-names=todos
+spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
 
 # Uncomment and set to true to enable aot compatibility
 # This flag disables all AOP related features (i.e. @SentryTransaction, @SentrySpan)
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
new file mode 100644
index 00000000000..b45e9c10853
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class CacheSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `cache put and get produce spans`() {
+    val restClient = testHelper.restClient
+
+    // Save a todo (triggers @CachePut -> cache.put span)
+    val todo = Todo(1L, "test-todo", false)
+    restClient.saveCachedTodo(todo)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.put")
+    }
+
+    testHelper.reset()
+
+    // Get the todo (triggers @Cacheable -> cache.get span, should be a hit)
+    restClient.getCachedTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.get")
+    }
+  }
+
+  @Test
+  fun `cache evict produces span`() {
+    val restClient = testHelper.restClient
+
+    restClient.deleteCachedTodo(1L)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.evict")
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
index 4f3d64524fd..01e07fc2526 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
@@ -58,6 +58,10 @@ dependencies {
   implementation(projects.sentryAsyncProfiler)
   implementation(projects.sentryOpentelemetry.sentryOpentelemetryOtlpSpring)
 
+  // cache tracing
+  implementation(libs.springboot4.starter.cache)
+  implementation(libs.caffeine)
+
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CacheController.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CacheController.java
new file mode 100644
index 00000000000..f453f81187c
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/CacheController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/cache/")
+public class CacheController {
+  private final TodoService todoService;
+
+  public CacheController(TodoService todoService) {
+    this.todoService = todoService;
+  }
+
+  @GetMapping("{id}")
+  Todo get(@PathVariable Long id) {
+    return todoService.get(id);
+  }
+
+  @PostMapping
+  Todo save(@RequestBody Todo todo) {
+    return todoService.save(todo);
+  }
+
+  @DeleteMapping("{id}")
+  void delete(@PathVariable Long id) {
+    todoService.delete(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SentryDemoApplication.java
index b4c58c4882e..1bf622154d0 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SentryDemoApplication.java
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/SentryDemoApplication.java
@@ -12,6 +12,7 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.restclient.RestTemplateBuilder;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
@@ -22,6 +23,7 @@
 import org.springframework.web.reactive.function.client.WebClient;
 
 @SpringBootApplication
+@EnableCaching
 @EnableScheduling
 public class SentryDemoApplication {
   public static void main(String[] args) {
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/TodoService.java b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/TodoService.java
new file mode 100644
index 00000000000..1a748a165a4
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/java/io/sentry/samples/spring/boot4/otlp/TodoService.java
@@ -0,0 +1,29 @@
+package io.sentry.samples.spring.boot4.otlp;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TodoService {
+  private final Map<Long, Todo> store = new ConcurrentHashMap<>();
+
+  @Cacheable(value = "todos", key = "#id")
+  public Todo get(Long id) {
+    return store.get(id);
+  }
+
+  @CachePut(value = "todos", key = "#todo.id")
+  public Todo save(Todo todo) {
+    store.put(todo.getId(), todo);
+    return todo;
+  }
+
+  @CacheEvict(value = "todos", key = "#id")
+  public void delete(Long id) {
+    store.remove(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/application.properties
index 43c0bd18c08..f9b35099062 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/main/resources/application.properties
@@ -20,6 +20,9 @@ sentry.logs.enabled=true
 sentry.profile-session-sample-rate=1.0
 sentry.profiling-traces-dir-path=tmp/sentry/profiling-traces
 sentry.profile-lifecycle=TRACE
+sentry.enable-cache-tracing=true
+spring.cache.cache-names=todos
+spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
 
 # Uncomment and set to true to enable aot compatibility
 # This flag disables all AOP related features (i.e. @SentryTransaction, @SentrySpan)
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
new file mode 100644
index 00000000000..b45e9c10853
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class CacheSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `cache put and get produce spans`() {
+    val restClient = testHelper.restClient
+
+    // Save a todo (triggers @CachePut -> cache.put span)
+    val todo = Todo(1L, "test-todo", false)
+    restClient.saveCachedTodo(todo)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.put")
+    }
+
+    testHelper.reset()
+
+    // Get the todo (triggers @Cacheable -> cache.get span, should be a hit)
+    restClient.getCachedTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.get")
+    }
+  }
+
+  @Test
+  fun `cache evict produces span`() {
+    val restClient = testHelper.restClient
+
+    restClient.deleteCachedTodo(1L)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.evict")
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
index b9986a31d02..cdcf65711a8 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
@@ -32,6 +32,10 @@ dependencies {
   implementation(libs.springboot4.starter.webflux)
   implementation(libs.springboot4.starter.webclient)
 
+  // cache tracing
+  implementation(libs.springboot4.starter.cache)
+  implementation(libs.caffeine)
+
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(projects.sentrySystemTestSupport)
   testImplementation(libs.apollo3.kotlin)
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/CacheController.java b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/CacheController.java
new file mode 100644
index 00000000000..3c2e66442de
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/CacheController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot4;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/cache/")
+public class CacheController {
+  private final TodoService todoService;
+
+  public CacheController(TodoService todoService) {
+    this.todoService = todoService;
+  }
+
+  @GetMapping("{id}")
+  Todo get(@PathVariable Long id) {
+    return todoService.get(id);
+  }
+
+  @PostMapping
+  Todo save(@RequestBody Todo todo) {
+    return todoService.save(todo);
+  }
+
+  @DeleteMapping("{id}")
+  void delete(@PathVariable Long id) {
+    todoService.delete(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java
index 72980871730..0d37be7634c 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java
@@ -2,10 +2,12 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.web.reactive.function.client.WebClient;
 
 @SpringBootApplication
+@EnableCaching
 public class SentryDemoApplication {
   public static void main(String[] args) {
     SpringApplication.run(SentryDemoApplication.class, args);
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/TodoService.java b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/TodoService.java
new file mode 100644
index 00000000000..c837ab8398a
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/java/io/sentry/samples/spring/boot4/TodoService.java
@@ -0,0 +1,29 @@
+package io.sentry.samples.spring.boot4;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TodoService {
+  private final Map<Long, Todo> store = new ConcurrentHashMap<>();
+
+  @Cacheable(value = "todos", key = "#id")
+  public Todo get(Long id) {
+    return store.get(id);
+  }
+
+  @CachePut(value = "todos", key = "#todo.id")
+  public Todo save(Todo todo) {
+    store.put(todo.getId(), todo);
+    return todo;
+  }
+
+  @CacheEvict(value = "todos", key = "#id")
+  public void delete(Long id) {
+    store.remove(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/resources/application.properties
index 9e9d6596e08..9fc969efd28 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/main/resources/application.properties
@@ -15,3 +15,6 @@ sentry.enable-spotlight=true
 sentry.profile-session-sample-rate=1.0
 sentry.profiling-traces-dir-path=tmp/sentry/profiling-traces
 sentry.profile-lifecycle=TRACE
+sentry.enable-cache-tracing=true
+spring.cache.cache-names=todos
+spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
new file mode 100644
index 00000000000..b45e9c10853
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class CacheSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `cache put and get produce spans`() {
+    val restClient = testHelper.restClient
+
+    // Save a todo (triggers @CachePut -> cache.put span)
+    val todo = Todo(1L, "test-todo", false)
+    restClient.saveCachedTodo(todo)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.put")
+    }
+
+    testHelper.reset()
+
+    // Get the todo (triggers @Cacheable -> cache.get span, should be a hit)
+    restClient.getCachedTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.get")
+    }
+  }
+
+  @Test
+  fun `cache evict produces span`() {
+    val restClient = testHelper.restClient
+
+    restClient.deleteCachedTodo(1L)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.evict")
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
index a7fa57dac83..f43cc47cc6d 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
@@ -57,6 +57,10 @@ dependencies {
   implementation(projects.sentryQuartz)
   implementation(projects.sentryAsyncProfiler)
 
+  // cache tracing
+  implementation(libs.springboot4.starter.cache)
+  implementation(libs.caffeine)
+
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/CacheController.java b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/CacheController.java
new file mode 100644
index 00000000000..3c2e66442de
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/CacheController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot4;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/cache/")
+public class CacheController {
+  private final TodoService todoService;
+
+  public CacheController(TodoService todoService) {
+    this.todoService = todoService;
+  }
+
+  @GetMapping("{id}")
+  Todo get(@PathVariable Long id) {
+    return todoService.get(id);
+  }
+
+  @PostMapping
+  Todo save(@RequestBody Todo todo) {
+    return todoService.save(todo);
+  }
+
+  @DeleteMapping("{id}")
+  void delete(@PathVariable Long id) {
+    todoService.delete(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java
index 71463a9a819..13d97fa8442 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/SentryDemoApplication.java
@@ -9,6 +9,7 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.restclient.RestTemplateBuilder;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
@@ -19,6 +20,7 @@
 import org.springframework.web.reactive.function.client.WebClient;
 
 @SpringBootApplication
+@EnableCaching
 @EnableScheduling
 public class SentryDemoApplication {
   public static void main(String[] args) {
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/TodoService.java b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/TodoService.java
new file mode 100644
index 00000000000..c837ab8398a
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/TodoService.java
@@ -0,0 +1,29 @@
+package io.sentry.samples.spring.boot4;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TodoService {
+  private final Map<Long, Todo> store = new ConcurrentHashMap<>();
+
+  @Cacheable(value = "todos", key = "#id")
+  public Todo get(Long id) {
+    return store.get(id);
+  }
+
+  @CachePut(value = "todos", key = "#todo.id")
+  public Todo save(Todo todo) {
+    store.put(todo.getId(), todo);
+    return todo;
+  }
+
+  @CacheEvict(value = "todos", key = "#id")
+  public void delete(Long id) {
+    store.remove(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-4/src/main/resources/application.properties
index 9ba7a54aaf8..8198059343a 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/main/resources/application.properties
@@ -20,6 +20,9 @@ sentry.logs.enabled=true
 sentry.profile-session-sample-rate=1.0
 sentry.profiling-traces-dir-path=tmp/sentry/profiling-traces
 sentry.profile-lifecycle=TRACE
+sentry.enable-cache-tracing=true
+spring.cache.cache-names=todos
+spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
 
 # Uncomment and set to true to enable aot compatibility
 # This flag disables all AOP related features (i.e. @SentryTransaction, @SentrySpan)
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
new file mode 100644
index 00000000000..b45e9c10853
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class CacheSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `cache put and get produce spans`() {
+    val restClient = testHelper.restClient
+
+    // Save a todo (triggers @CachePut -> cache.put span)
+    val todo = Todo(1L, "test-todo", false)
+    restClient.saveCachedTodo(todo)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.put")
+    }
+
+    testHelper.reset()
+
+    // Get the todo (triggers @Cacheable -> cache.get span, should be a hit)
+    restClient.getCachedTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.get")
+    }
+  }
+
+  @Test
+  fun `cache evict produces span`() {
+    val restClient = testHelper.restClient
+
+    restClient.deleteCachedTodo(1L)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.evict")
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
index b0fbae0ddc4..86914467a6d 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
@@ -52,6 +52,10 @@ dependencies {
   implementation(projects.sentryAsyncProfiler)
   implementation(projects.sentryOpentelemetry.sentryOpentelemetryAgentlessSpring)
 
+  // cache tracing
+  implementation(libs.springboot3.starter.cache)
+  implementation(libs.caffeine)
+
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
new file mode 100644
index 00000000000..1327d5e6e29
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot.jakarta;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/cache/")
+public class CacheController {
+  private final TodoService todoService;
+
+  public CacheController(TodoService todoService) {
+    this.todoService = todoService;
+  }
+
+  @GetMapping("{id}")
+  Todo get(@PathVariable Long id) {
+    return todoService.get(id);
+  }
+
+  @PostMapping
+  Todo save(@RequestBody Todo todo) {
+    return todoService.save(todo);
+  }
+
+  @DeleteMapping("{id}")
+  void delete(@PathVariable Long id) {
+    todoService.delete(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
index 7f412eaa0d6..8cbd7875b5f 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
@@ -11,6 +11,7 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
@@ -21,6 +22,7 @@
 import org.springframework.web.reactive.function.client.WebClient;
 
 @SpringBootApplication
+@EnableCaching
 @EnableScheduling
 public class SentryDemoApplication {
   public static void main(String[] args) {
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
new file mode 100644
index 00000000000..70a145558c2
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
@@ -0,0 +1,29 @@
+package io.sentry.samples.spring.boot.jakarta;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TodoService {
+  private final Map<Long, Todo> store = new ConcurrentHashMap<>();
+
+  @Cacheable(value = "todos", key = "#id")
+  public Todo get(Long id) {
+    return store.get(id);
+  }
+
+  @CachePut(value = "todos", key = "#todo.id")
+  public Todo save(Todo todo) {
+    store.put(todo.getId(), todo);
+    return todo;
+  }
+
+  @CacheEvict(value = "todos", key = "#id")
+  public void delete(Long id) {
+    store.remove(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/resources/application.properties
index d19c33a3d1b..a3a59d290b1 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/resources/application.properties
@@ -35,6 +35,11 @@ spring.graphql.graphiql.enabled=true
 spring.graphql.websocket.path=/graphql
 spring.quartz.job-store-type=memory
 
+# Cache tracing
+sentry.enable-cache-tracing=true
+spring.cache.cache-names=todos
+spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
+
 # OTEL configuration
 otel.propagators=tracecontext,baggage,sentry
 otel.logs.exporter=none
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
new file mode 100644
index 00000000000..b45e9c10853
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class CacheSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `cache put and get produce spans`() {
+    val restClient = testHelper.restClient
+
+    // Save a todo (triggers @CachePut -> cache.put span)
+    val todo = Todo(1L, "test-todo", false)
+    restClient.saveCachedTodo(todo)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.put")
+    }
+
+    testHelper.reset()
+
+    // Get the todo (triggers @Cacheable -> cache.get span, should be a hit)
+    restClient.getCachedTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.get")
+    }
+  }
+
+  @Test
+  fun `cache evict produces span`() {
+    val restClient = testHelper.restClient
+
+    restClient.deleteCachedTodo(1L)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.evict")
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
index 0eeaf30d2bd..37d7a94eec0 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
@@ -56,6 +56,10 @@ dependencies {
   implementation(libs.otel)
   implementation(projects.sentryAsyncProfiler)
 
+  // cache tracing
+  implementation(libs.springboot3.starter.cache)
+  implementation(libs.caffeine)
+
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
new file mode 100644
index 00000000000..1327d5e6e29
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot.jakarta;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/cache/")
+public class CacheController {
+  private final TodoService todoService;
+
+  public CacheController(TodoService todoService) {
+    this.todoService = todoService;
+  }
+
+  @GetMapping("{id}")
+  Todo get(@PathVariable Long id) {
+    return todoService.get(id);
+  }
+
+  @PostMapping
+  Todo save(@RequestBody Todo todo) {
+    return todoService.save(todo);
+  }
+
+  @DeleteMapping("{id}")
+  void delete(@PathVariable Long id) {
+    todoService.delete(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
index a6eb46f4c74..cd550bfbadf 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
@@ -11,6 +11,7 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
@@ -21,6 +22,7 @@
 import org.springframework.web.reactive.function.client.WebClient;
 
 @SpringBootApplication
+@EnableCaching
 @EnableScheduling
 public class SentryDemoApplication {
   public static void main(String[] args) {
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
new file mode 100644
index 00000000000..70a145558c2
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
@@ -0,0 +1,29 @@
+package io.sentry.samples.spring.boot.jakarta;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TodoService {
+  private final Map<Long, Todo> store = new ConcurrentHashMap<>();
+
+  @Cacheable(value = "todos", key = "#id")
+  public Todo get(Long id) {
+    return store.get(id);
+  }
+
+  @CachePut(value = "todos", key = "#todo.id")
+  public Todo save(Todo todo) {
+    store.put(todo.getId(), todo);
+    return todo;
+  }
+
+  @CacheEvict(value = "todos", key = "#id")
+  public void delete(Long id) {
+    store.remove(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/resources/application.properties
index 6b57706019b..12a9ca17269 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/resources/application.properties
@@ -34,3 +34,8 @@ spring.datasource.password=
 spring.graphql.graphiql.enabled=true
 spring.graphql.websocket.path=/graphql
 spring.quartz.job-store-type=memory
+
+# Cache tracing
+sentry.enable-cache-tracing=true
+spring.cache.cache-names=todos
+spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
new file mode 100644
index 00000000000..b45e9c10853
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class CacheSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `cache put and get produce spans`() {
+    val restClient = testHelper.restClient
+
+    // Save a todo (triggers @CachePut -> cache.put span)
+    val todo = Todo(1L, "test-todo", false)
+    restClient.saveCachedTodo(todo)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.put")
+    }
+
+    testHelper.reset()
+
+    // Get the todo (triggers @Cacheable -> cache.get span, should be a hit)
+    restClient.getCachedTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.get")
+    }
+  }
+
+  @Test
+  fun `cache evict produces span`() {
+    val restClient = testHelper.restClient
+
+    restClient.deleteCachedTodo(1L)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.evict")
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
index 570d35b727b..a945b87109a 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
@@ -55,6 +55,10 @@ dependencies {
   implementation(projects.sentryAsyncProfiler)
   implementation(projects.sentryOpenfeature)
 
+  // cache tracing
+  implementation(libs.springboot3.starter.cache)
+  implementation(libs.caffeine)
+
   // OpenFeature SDK
   implementation(libs.openfeature)
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
new file mode 100644
index 00000000000..1327d5e6e29
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot.jakarta;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/cache/")
+public class CacheController {
+  private final TodoService todoService;
+
+  public CacheController(TodoService todoService) {
+    this.todoService = todoService;
+  }
+
+  @GetMapping("{id}")
+  Todo get(@PathVariable Long id) {
+    return todoService.get(id);
+  }
+
+  @PostMapping
+  Todo save(@RequestBody Todo todo) {
+    return todoService.save(todo);
+  }
+
+  @DeleteMapping("{id}")
+  void delete(@PathVariable Long id) {
+    todoService.delete(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
index 8050cb8e74c..e818cbe42ff 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
@@ -9,6 +9,7 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
@@ -19,6 +20,7 @@
 import org.springframework.web.reactive.function.client.WebClient;
 
 @SpringBootApplication
+@EnableCaching
 @EnableScheduling
 public class SentryDemoApplication {
   public static void main(String[] args) {
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
new file mode 100644
index 00000000000..70a145558c2
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
@@ -0,0 +1,29 @@
+package io.sentry.samples.spring.boot.jakarta;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TodoService {
+  private final Map<Long, Todo> store = new ConcurrentHashMap<>();
+
+  @Cacheable(value = "todos", key = "#id")
+  public Todo get(Long id) {
+    return store.get(id);
+  }
+
+  @CachePut(value = "todos", key = "#todo.id")
+  public Todo save(Todo todo) {
+    store.put(todo.getId(), todo);
+    return todo;
+  }
+
+  @CacheEvict(value = "todos", key = "#id")
+  public void delete(Long id) {
+    store.remove(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application.properties
index 9830709c313..60b92d369d5 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application.properties
@@ -35,3 +35,8 @@ spring.graphql.graphiql.enabled=true
 spring.graphql.websocket.path=/graphql
 spring.quartz.job-store-type=memory
 
+# Cache tracing
+sentry.enable-cache-tracing=true
+spring.cache.cache-names=todos
+spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
+
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
new file mode 100644
index 00000000000..b45e9c10853
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class CacheSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `cache put and get produce spans`() {
+    val restClient = testHelper.restClient
+
+    // Save a todo (triggers @CachePut -> cache.put span)
+    val todo = Todo(1L, "test-todo", false)
+    restClient.saveCachedTodo(todo)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.put")
+    }
+
+    testHelper.reset()
+
+    // Get the todo (triggers @Cacheable -> cache.get span, should be a hit)
+    restClient.getCachedTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.get")
+    }
+  }
+
+  @Test
+  fun `cache evict produces span`() {
+    val restClient = testHelper.restClient
+
+    restClient.deleteCachedTodo(1L)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.evict")
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
index 1cdff5cab38..a45249830f4 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
@@ -31,6 +31,10 @@ dependencies {
   implementation(libs.springboot3.starter.graphql)
   implementation(libs.springboot3.starter.webflux)
 
+  // cache tracing
+  implementation(libs.springboot3.starter.cache)
+  implementation(libs.caffeine)
+
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(projects.sentrySystemTestSupport)
   testImplementation(libs.apollo3.kotlin)
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
new file mode 100644
index 00000000000..1327d5e6e29
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/CacheController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot.jakarta;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/cache/")
+public class CacheController {
+  private final TodoService todoService;
+
+  public CacheController(TodoService todoService) {
+    this.todoService = todoService;
+  }
+
+  @GetMapping("{id}")
+  Todo get(@PathVariable Long id) {
+    return todoService.get(id);
+  }
+
+  @PostMapping
+  Todo save(@RequestBody Todo todo) {
+    return todoService.save(todo);
+  }
+
+  @DeleteMapping("{id}")
+  void delete(@PathVariable Long id) {
+    todoService.delete(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
index 926298bb97b..baa6d30e5c3 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/SentryDemoApplication.java
@@ -2,10 +2,12 @@
 
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.web.reactive.function.client.WebClient;
 
 @SpringBootApplication
+@EnableCaching
 public class SentryDemoApplication {
   public static void main(String[] args) {
     SpringApplication.run(SentryDemoApplication.class, args);
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
new file mode 100644
index 00000000000..70a145558c2
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/TodoService.java
@@ -0,0 +1,29 @@
+package io.sentry.samples.spring.boot.jakarta;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TodoService {
+  private final Map<Long, Todo> store = new ConcurrentHashMap<>();
+
+  @Cacheable(value = "todos", key = "#id")
+  public Todo get(Long id) {
+    return store.get(id);
+  }
+
+  @CachePut(value = "todos", key = "#todo.id")
+  public Todo save(Todo todo) {
+    store.put(todo.getId(), todo);
+    return todo;
+  }
+
+  @CacheEvict(value = "todos", key = "#id")
+  public void delete(Long id) {
+    store.remove(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/resources/application.properties
index 3bc4087b288..02eaf0c731c 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/main/resources/application.properties
@@ -16,3 +16,8 @@ sentry.in-app-includes="io.sentry.samples"
 sentry.profile-session-sample-rate=1.0
 sentry.profiling-traces-dir-path=tmp/sentry/profiling-traces
 sentry.profile-lifecycle=TRACE
+
+# Cache tracing
+sentry.enable-cache-tracing=true
+spring.cache.cache-names=todos
+spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
new file mode 100644
index 00000000000..b45e9c10853
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class CacheSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `cache put and get produce spans`() {
+    val restClient = testHelper.restClient
+
+    // Save a todo (triggers @CachePut -> cache.put span)
+    val todo = Todo(1L, "test-todo", false)
+    restClient.saveCachedTodo(todo)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.put")
+    }
+
+    testHelper.reset()
+
+    // Get the todo (triggers @Cacheable -> cache.get span, should be a hit)
+    restClient.getCachedTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.get")
+    }
+  }
+
+  @Test
+  fun `cache evict produces span`() {
+    val restClient = testHelper.restClient
+
+    restClient.deleteCachedTodo(1L)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.evict")
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
index be2b4583fb6..b6fcd675cf3 100644
--- a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
@@ -40,7 +40,9 @@ dependencies {
   implementation(libs.springboot.starter.security)
   implementation(libs.springboot.starter.web)
   implementation(libs.springboot.starter.webflux)
+  implementation(libs.springboot.starter.cache)
   implementation(libs.springboot.starter.websocket)
+  implementation(libs.caffeine)
   implementation(Config.Libs.aspectj)
   implementation(Config.Libs.kotlinReflect)
   implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
diff --git a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/CacheController.java b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/CacheController.java
new file mode 100644
index 00000000000..e85f201139f
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/CacheController.java
@@ -0,0 +1,34 @@
+package io.sentry.samples.spring.boot;
+
+import org.springframework.web.bind.annotation.DeleteMapping;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping("/cache/")
+public class CacheController {
+  private final TodoService todoService;
+
+  public CacheController(TodoService todoService) {
+    this.todoService = todoService;
+  }
+
+  @GetMapping("{id}")
+  Todo get(@PathVariable Long id) {
+    return todoService.get(id);
+  }
+
+  @PostMapping
+  Todo save(@RequestBody Todo todo) {
+    return todoService.save(todo);
+  }
+
+  @DeleteMapping("{id}")
+  void delete(@PathVariable Long id) {
+    todoService.delete(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/SentryDemoApplication.java b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/SentryDemoApplication.java
index b4f46260997..a08770b1029 100644
--- a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/SentryDemoApplication.java
+++ b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/SentryDemoApplication.java
@@ -9,6 +9,7 @@
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.web.client.RestTemplateBuilder;
+import org.springframework.cache.annotation.EnableCaching;
 import org.springframework.context.annotation.Bean;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
@@ -18,6 +19,7 @@
 import org.springframework.web.reactive.function.client.WebClient;
 
 @SpringBootApplication
+@EnableCaching
 @EnableScheduling
 public class SentryDemoApplication {
   public static void main(String[] args) {
diff --git a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/TodoService.java b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/TodoService.java
new file mode 100644
index 00000000000..81aa944c8be
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/TodoService.java
@@ -0,0 +1,29 @@
+package io.sentry.samples.spring.boot;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.springframework.cache.annotation.CacheEvict;
+import org.springframework.cache.annotation.CachePut;
+import org.springframework.cache.annotation.Cacheable;
+import org.springframework.stereotype.Service;
+
+@Service
+public class TodoService {
+  private final Map<Long, Todo> store = new ConcurrentHashMap<>();
+
+  @Cacheable(value = "todos", key = "#id")
+  public Todo get(Long id) {
+    return store.get(id);
+  }
+
+  @CachePut(value = "todos", key = "#todo.id")
+  public Todo save(Todo todo) {
+    store.put(todo.getId(), todo);
+    return todo;
+  }
+
+  @CacheEvict(value = "todos", key = "#id")
+  public void delete(Long id) {
+    store.remove(id);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot/src/main/resources/application.properties
index d39f38d7182..4e97e7a1eb8 100644
--- a/sentry-samples/sentry-samples-spring-boot/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot/src/main/resources/application.properties
@@ -20,6 +20,11 @@ sentry.profile-session-sample-rate=1.0
 sentry.profiling-traces-dir-path=tmp/sentry/profiling-traces
 sentry.profile-lifecycle=TRACE
 
+# Cache tracing
+sentry.enable-cache-tracing=true
+spring.cache.cache-names=todos
+spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
+
 # Database configuration
 spring.datasource.url=jdbc:p6spy:hsqldb:mem:testdb
 spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver
diff --git a/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt b/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
new file mode 100644
index 00000000000..b45e9c10853
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/CacheSystemTest.kt
@@ -0,0 +1,51 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class CacheSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `cache put and get produce spans`() {
+    val restClient = testHelper.restClient
+
+    // Save a todo (triggers @CachePut -> cache.put span)
+    val todo = Todo(1L, "test-todo", false)
+    restClient.saveCachedTodo(todo)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.put")
+    }
+
+    testHelper.reset()
+
+    // Get the todo (triggers @Cacheable -> cache.get span, should be a hit)
+    restClient.getCachedTodo(1L)
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.get")
+    }
+  }
+
+  @Test
+  fun `cache evict produces span`() {
+    val restClient = testHelper.restClient
+
+    restClient.deleteCachedTodo(1L)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "cache.evict")
+    }
+  }
+}
diff --git a/sentry-spring-7/api/sentry-spring-7.api b/sentry-spring-7/api/sentry-spring-7.api
index 3a57c13e835..71a8a022bf6 100644
--- a/sentry-spring-7/api/sentry-spring-7.api
+++ b/sentry-spring-7/api/sentry-spring-7.api
@@ -104,6 +104,35 @@ public final class io/sentry/spring7/SpringSecuritySentryUserProvider : io/sentr
 	public fun provideUser ()Lio/sentry/protocol/User;
 }
 
+public final class io/sentry/spring7/cache/SentryCacheBeanPostProcessor : org/springframework/beans/factory/config/BeanPostProcessor, org/springframework/core/PriorityOrdered {
+	public fun <init> ()V
+	public fun getOrder ()I
+	public fun postProcessAfterInitialization (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class io/sentry/spring7/cache/SentryCacheManagerWrapper : org/springframework/cache/CacheManager {
+	public fun <init> (Lorg/springframework/cache/CacheManager;Lio/sentry/IScopes;)V
+	public fun getCache (Ljava/lang/String;)Lorg/springframework/cache/Cache;
+	public fun getCacheNames ()Ljava/util/Collection;
+}
+
+public final class io/sentry/spring7/cache/SentryCacheWrapper : org/springframework/cache/Cache {
+	public fun <init> (Lorg/springframework/cache/Cache;Lio/sentry/IScopes;)V
+	public fun clear ()V
+	public fun evict (Ljava/lang/Object;)V
+	public fun evictIfPresent (Ljava/lang/Object;)Z
+	public fun get (Ljava/lang/Object;)Lorg/springframework/cache/Cache$ValueWrapper;
+	public fun get (Ljava/lang/Object;Ljava/lang/Class;)Ljava/lang/Object;
+	public fun get (Ljava/lang/Object;Ljava/util/concurrent/Callable;)Ljava/lang/Object;
+	public fun getName ()Ljava/lang/String;
+	public fun getNativeCache ()Ljava/lang/Object;
+	public fun invalidate ()Z
+	public fun put (Ljava/lang/Object;Ljava/lang/Object;)V
+	public fun putIfAbsent (Ljava/lang/Object;Ljava/lang/Object;)Lorg/springframework/cache/Cache$ValueWrapper;
+	public fun retrieve (Ljava/lang/Object;)Ljava/util/concurrent/CompletableFuture;
+	public fun retrieve (Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/util/concurrent/CompletableFuture;
+}
+
 public abstract interface annotation class io/sentry/spring7/checkin/SentryCheckIn : java/lang/annotation/Annotation {
 	public abstract fun heartbeat ()Z
 	public abstract fun monitorSlug ()Ljava/lang/String;
diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheBeanPostProcessor.java b/sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheBeanPostProcessor.java
new file mode 100644
index 00000000000..b6569a9953b
--- /dev/null
+++ b/sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheBeanPostProcessor.java
@@ -0,0 +1,29 @@
+package io.sentry.spring7.cache;
+
+import io.sentry.ScopesAdapter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.cache.CacheManager;
+import org.springframework.core.Ordered;
+import org.springframework.core.PriorityOrdered;
+
+/** Wraps {@link CacheManager} beans in {@link SentryCacheManagerWrapper} for instrumentation. */
+@ApiStatus.Internal
+public final class SentryCacheBeanPostProcessor implements BeanPostProcessor, PriorityOrdered {
+
+  @Override
+  public @NotNull Object postProcessAfterInitialization(
+      final @NotNull Object bean, final @NotNull String beanName) throws BeansException {
+    if (bean instanceof CacheManager && !(bean instanceof SentryCacheManagerWrapper)) {
+      return new SentryCacheManagerWrapper((CacheManager) bean, ScopesAdapter.getInstance());
+    }
+    return bean;
+  }
+
+  @Override
+  public int getOrder() {
+    return Ordered.LOWEST_PRECEDENCE;
+  }
+}
diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheManagerWrapper.java b/sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheManagerWrapper.java
new file mode 100644
index 00000000000..97ac313bd91
--- /dev/null
+++ b/sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheManagerWrapper.java
@@ -0,0 +1,37 @@
+package io.sentry.spring7.cache;
+
+import io.sentry.IScopes;
+import java.util.Collection;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+
+/** Wraps a Spring {@link CacheManager} to return Sentry-instrumented caches. */
+@ApiStatus.Internal
+public final class SentryCacheManagerWrapper implements CacheManager {
+
+  private final @NotNull CacheManager delegate;
+  private final @NotNull IScopes scopes;
+
+  public SentryCacheManagerWrapper(
+      final @NotNull CacheManager delegate, final @NotNull IScopes scopes) {
+    this.delegate = delegate;
+    this.scopes = scopes;
+  }
+
+  @Override
+  public @Nullable Cache getCache(final @NotNull String name) {
+    final Cache cache = delegate.getCache(name);
+    if (cache == null || cache instanceof SentryCacheWrapper) {
+      return cache;
+    }
+    return new SentryCacheWrapper(cache, scopes);
+  }
+
+  @Override
+  public @NotNull Collection<String> getCacheNames() {
+    return delegate.getCacheNames();
+  }
+}
diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheWrapper.java b/sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheWrapper.java
new file mode 100644
index 00000000000..e5cb9ce87e9
--- /dev/null
+++ b/sentry-spring-7/src/main/java/io/sentry/spring7/cache/SentryCacheWrapper.java
@@ -0,0 +1,326 @@
+package io.sentry.spring7.cache;
+
+import io.sentry.IScopes;
+import io.sentry.ISpan;
+import io.sentry.SpanDataConvention;
+import io.sentry.SpanOptions;
+import io.sentry.SpanStatus;
+import java.util.Collections;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.cache.Cache;
+
+/** Wraps a Spring {@link Cache} to create Sentry spans for cache operations. */
+@ApiStatus.Internal
+public final class SentryCacheWrapper implements Cache {
+
+  private static final String TRACE_ORIGIN = "auto.cache.spring";
+
+  private final @NotNull Cache delegate;
+  private final @NotNull IScopes scopes;
+
+  public SentryCacheWrapper(final @NotNull Cache delegate, final @NotNull IScopes scopes) {
+    this.delegate = delegate;
+    this.scopes = scopes;
+  }
+
+  @Override
+  public @NotNull String getName() {
+    return delegate.getName();
+  }
+
+  @Override
+  public @NotNull Object getNativeCache() {
+    return delegate.getNativeCache();
+  }
+
+  @Override
+  public @Nullable ValueWrapper get(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key);
+    }
+    try {
+      final ValueWrapper result = delegate.get(key);
+      span.setData(SpanDataConvention.CACHE_HIT, result != null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable <T> T get(final @NotNull Object key, final @Nullable Class<T> type) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key, type);
+    }
+    try {
+      final T result = delegate.get(key, type);
+      span.setData(SpanDataConvention.CACHE_HIT, result != null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable <T> T get(final @NotNull Object key, final @NotNull Callable<T> valueLoader) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key, valueLoader);
+    }
+    try {
+      final AtomicBoolean loaderInvoked = new AtomicBoolean(false);
+      final T result =
+          delegate.get(
+              key,
+              () -> {
+                loaderInvoked.set(true);
+                return valueLoader.call();
+              });
+      span.setData(SpanDataConvention.CACHE_HIT, !loaderInvoked.get());
+      span.setData(SpanDataConvention.CACHE_WRITE, loaderInvoked.get());
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable CompletableFuture<?> retrieve(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "retrieve");
+    if (span == null) {
+      return delegate.retrieve(key);
+    }
+    final CompletableFuture<?> result;
+    try {
+      result = delegate.retrieve(key);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      span.finish();
+      throw e;
+    }
+    if (result == null) {
+      span.setData(SpanDataConvention.CACHE_HIT, false);
+      span.setStatus(SpanStatus.OK);
+      span.finish();
+      return null;
+    }
+    return result.whenComplete(
+        (value, throwable) -> {
+          if (throwable != null) {
+            span.setStatus(SpanStatus.INTERNAL_ERROR);
+            span.setThrowable(throwable);
+          } else {
+            span.setData(SpanDataConvention.CACHE_HIT, value != null);
+            span.setStatus(SpanStatus.OK);
+          }
+          span.finish();
+        });
+  }
+
+  @Override
+  public <T> CompletableFuture<T> retrieve(
+      final @NotNull Object key, final @NotNull Supplier<CompletableFuture<T>> valueLoader) {
+    final ISpan span = startSpan(key, "retrieve");
+    if (span == null) {
+      return delegate.retrieve(key, valueLoader);
+    }
+    final AtomicBoolean loaderInvoked = new AtomicBoolean(false);
+    final CompletableFuture<T> result;
+    try {
+      result =
+          delegate.retrieve(
+              key,
+              () -> {
+                loaderInvoked.set(true);
+                return valueLoader.get();
+              });
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      span.finish();
+      throw e;
+    }
+    return result.whenComplete(
+        (value, throwable) -> {
+          if (throwable != null) {
+            span.setStatus(SpanStatus.INTERNAL_ERROR);
+            span.setThrowable(throwable);
+          } else {
+            span.setData(SpanDataConvention.CACHE_HIT, !loaderInvoked.get());
+            span.setData(SpanDataConvention.CACHE_WRITE, loaderInvoked.get());
+            span.setStatus(SpanStatus.OK);
+          }
+          span.finish();
+        });
+  }
+
+  @Override
+  public void put(final @NotNull Object key, final @Nullable Object value) {
+    final ISpan span = startSpan(key, "put");
+    if (span == null) {
+      delegate.put(key, value);
+      return;
+    }
+    try {
+      delegate.put(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable ValueWrapper putIfAbsent(
+      final @NotNull Object key, final @Nullable Object value) {
+    final ISpan span = startSpan(key, "putIfAbsent");
+    if (span == null) {
+      return delegate.putIfAbsent(key, value);
+    }
+    try {
+      final ValueWrapper result = delegate.putIfAbsent(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, result == null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void evict(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "evict");
+    if (span == null) {
+      delegate.evict(key);
+      return;
+    }
+    try {
+      delegate.evict(key);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean evictIfPresent(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "evictIfPresent");
+    if (span == null) {
+      return delegate.evictIfPresent(key);
+    }
+    try {
+      final boolean result = delegate.evictIfPresent(key);
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void clear() {
+    final ISpan span = startSpan(null, "clear");
+    if (span == null) {
+      delegate.clear();
+      return;
+    }
+    try {
+      delegate.clear();
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean invalidate() {
+    final ISpan span = startSpan(null, "invalidate");
+    if (span == null) {
+      return delegate.invalidate();
+    }
+    try {
+      final boolean result = delegate.invalidate();
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  private @Nullable ISpan startSpan(
+      final @Nullable Object key, final @NotNull String operationName) {
+    if (!scopes.getOptions().isEnableCacheTracing()) {
+      return null;
+    }
+
+    final ISpan activeSpan = scopes.getSpan();
+    if (activeSpan == null || activeSpan.isNoOp()) {
+      return null;
+    }
+
+    final SpanOptions spanOptions = new SpanOptions();
+    spanOptions.setOrigin(TRACE_ORIGIN);
+    final String keyString = key != null ? String.valueOf(key) : null;
+    final ISpan span = activeSpan.startChild("cache." + operationName, keyString, spanOptions);
+    if (span.isNoOp()) {
+      return null;
+    }
+    if (keyString != null) {
+      span.setData(SpanDataConvention.CACHE_KEY, Collections.singletonList(keyString));
+    }
+    span.setData(SpanDataConvention.CACHE_OPERATION, operationName);
+    return span;
+  }
+}
diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheBeanPostProcessorTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheBeanPostProcessorTest.kt
new file mode 100644
index 00000000000..54c5e696d6a
--- /dev/null
+++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheBeanPostProcessorTest.kt
@@ -0,0 +1,44 @@
+package io.sentry.spring7.cache
+
+import io.sentry.IScopes
+import kotlin.test.Test
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.springframework.cache.CacheManager
+
+class SentryCacheBeanPostProcessorTest {
+
+  private val scopes: IScopes = mock()
+
+  @Test
+  fun `wraps CacheManager beans in SentryCacheManagerWrapper`() {
+    val cacheManager = mock<CacheManager>()
+    val processor = SentryCacheBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(cacheManager, "cacheManager")
+
+    assertTrue(result is SentryCacheManagerWrapper)
+  }
+
+  @Test
+  fun `does not double-wrap SentryCacheManagerWrapper`() {
+    val delegate = mock<CacheManager>()
+    val alreadyWrapped = SentryCacheManagerWrapper(delegate, scopes)
+    val processor = SentryCacheBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(alreadyWrapped, "cacheManager")
+
+    assertSame(alreadyWrapped, result)
+  }
+
+  @Test
+  fun `does not wrap non-CacheManager beans`() {
+    val someBean = "not a cache manager"
+    val processor = SentryCacheBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(someBean, "someBean")
+
+    assertSame(someBean, result)
+  }
+}
diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheManagerWrapperTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheManagerWrapperTest.kt
new file mode 100644
index 00000000000..dbc5992b7e0
--- /dev/null
+++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheManagerWrapperTest.kt
@@ -0,0 +1,61 @@
+package io.sentry.spring7.cache
+
+import io.sentry.IScopes
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+import org.springframework.cache.Cache
+import org.springframework.cache.CacheManager
+
+class SentryCacheManagerWrapperTest {
+
+  private val scopes: IScopes = mock()
+  private val delegate: CacheManager = mock()
+
+  @Test
+  fun `getCache wraps returned cache in SentryCacheWrapper`() {
+    val cache = mock<Cache>()
+    whenever(delegate.getCache("test")).thenReturn(cache)
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.getCache("test")
+
+    assertTrue(result is SentryCacheWrapper)
+  }
+
+  @Test
+  fun `getCache returns null when delegate returns null`() {
+    whenever(delegate.getCache("missing")).thenReturn(null)
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.getCache("missing")
+
+    assertNull(result)
+  }
+
+  @Test
+  fun `getCache does not double-wrap SentryCacheWrapper`() {
+    val innerCache = mock<Cache>()
+    val alreadyWrapped = SentryCacheWrapper(innerCache, scopes)
+    whenever(delegate.getCache("test")).thenReturn(alreadyWrapped)
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.getCache("test")
+
+    assertSame(alreadyWrapped, result)
+  }
+
+  @Test
+  fun `getCacheNames delegates to underlying cache manager`() {
+    whenever(delegate.cacheNames).thenReturn(listOf("cache1", "cache2"))
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.cacheNames
+
+    assertEquals(listOf("cache1", "cache2"), result)
+  }
+}
diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheWrapperTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheWrapperTest.kt
new file mode 100644
index 00000000000..ef056e7fdb5
--- /dev/null
+++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/cache/SentryCacheWrapperTest.kt
@@ -0,0 +1,530 @@
+package io.sentry.spring7.cache
+
+import io.sentry.IScopes
+import io.sentry.SentryOptions
+import io.sentry.SentryTracer
+import io.sentry.SpanDataConvention
+import io.sentry.SpanStatus
+import io.sentry.TransactionContext
+import java.util.concurrent.Callable
+import java.util.concurrent.CompletableFuture
+import java.util.function.Supplier
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.springframework.cache.Cache
+
+class SentryCacheWrapperTest {
+
+  private lateinit var scopes: IScopes
+  private lateinit var delegate: Cache
+  private lateinit var options: SentryOptions
+
+  @BeforeTest
+  fun setup() {
+    scopes = mock()
+    delegate = mock()
+    options = SentryOptions().apply { isEnableCacheTracing = true }
+    whenever(scopes.options).thenReturn(options)
+    whenever(delegate.name).thenReturn("testCache")
+  }
+
+  private fun createTransaction(): SentryTracer {
+    val tx = SentryTracer(TransactionContext("tx", "op"), scopes)
+    whenever(scopes.span).thenReturn(tx)
+    return tx
+  }
+
+  // -- get(Object key) --
+
+  @Test
+  fun `get with ValueWrapper creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val valueWrapper = mock<Cache.ValueWrapper>()
+    whenever(delegate.get("myKey")).thenReturn(valueWrapper)
+
+    val result = wrapper.get("myKey")
+
+    assertEquals(valueWrapper, result)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.get", span.operation)
+    assertEquals("myKey", span.description)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_HIT))
+    assertNull(span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("auto.cache.spring", span.spanContext.origin)
+    assertEquals("get", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  @Test
+  fun `get with ValueWrapper creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    val result = wrapper.get("myKey")
+
+    assertNull(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- get(Object key, Class<T>) --
+
+  @Test
+  fun `get with type creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey", String::class.java)).thenReturn("value")
+
+    val result = wrapper.get("myKey", String::class.java)
+
+    assertEquals("value", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  @Test
+  fun `get with type creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey", String::class.java)).thenReturn(null)
+
+    val result = wrapper.get("myKey", String::class.java)
+
+    assertNull(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  @Test
+  fun `get with type sets error status and throwable on exception`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("cache error")
+    whenever(delegate.get("myKey", String::class.java)).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { wrapper.get("myKey", String::class.java) }
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+  }
+
+  // -- get(Object key, Callable<T>) --
+
+  @Test
+  fun `get with callable creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache hit: delegate returns value without invoking the loader
+    whenever(delegate.get(eq("myKey"), any<Callable<String>>())).thenReturn("cached")
+
+    val result = wrapper.get("myKey", Callable { "loaded" })
+
+    assertEquals("cached", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  @Test
+  fun `get with callable creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache miss: delegate invokes the loader callable
+    whenever(delegate.get(eq("myKey"), any<Callable<String>>())).thenAnswer { invocation ->
+      val loader = invocation.getArgument<Callable<String>>(1)
+      loader.call()
+    }
+
+    val result = wrapper.get("myKey", Callable { "loaded" })
+
+    assertEquals("loaded", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- retrieve(Object key) --
+
+  @Test
+  fun `retrieve creates span with cache hit true when future resolves with value`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve("myKey")).thenReturn(CompletableFuture.completedFuture("value"))
+
+    val result = wrapper.retrieve("myKey")
+
+    assertEquals("value", result!!.get())
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.retrieve", span.operation)
+    assertEquals("myKey", span.description)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_HIT))
+    assertNull(span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("retrieve", span.getData(SpanDataConvention.CACHE_OPERATION))
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve creates span with cache hit false when future resolves with null`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve("myKey")).thenReturn(CompletableFuture.completedFuture(null))
+
+    val result = wrapper.retrieve("myKey")
+
+    assertNull(result!!.get())
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+    assertTrue(tx.spans.first().isFinished)
+  }
+
+  @Test
+  fun `retrieve creates span with cache hit false when delegate returns null`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve("myKey")).thenReturn(null)
+
+    val result = wrapper.retrieve("myKey")
+
+    assertNull(result)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(false, span.getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals(SpanStatus.OK, span.status)
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve sets error status when future completes exceptionally`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("async cache error")
+    whenever(delegate.retrieve("myKey"))
+      .thenReturn(CompletableFuture<Any>().also { it.completeExceptionally(exception) })
+
+    val result = wrapper.retrieve("myKey")
+
+    assertFailsWith<Exception> { result!!.get() }
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve sets error status when delegate throws synchronously`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("sync error")
+    whenever(delegate.retrieve("myKey")).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { wrapper.retrieve("myKey") }
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve does not create span when tracing is disabled`() {
+    options.isEnableCacheTracing = false
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve("myKey")).thenReturn(CompletableFuture.completedFuture("value"))
+
+    wrapper.retrieve("myKey")
+
+    verify(delegate).retrieve("myKey")
+    assertEquals(0, tx.spans.size)
+  }
+
+  // -- retrieve(Object key, Supplier<CompletableFuture<T>>) --
+
+  @Test
+  fun `retrieve with loader creates span with cache hit true when loader not invoked`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache hit: delegate returns value without invoking the loader
+    whenever(delegate.retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>()))
+      .thenReturn(CompletableFuture.completedFuture("cached"))
+
+    val result = wrapper.retrieve("myKey") { CompletableFuture.completedFuture("loaded") }
+
+    assertEquals("cached", result.get())
+    assertEquals(1, tx.spans.size)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+    assertTrue(tx.spans.first().isFinished)
+  }
+
+  @Test
+  fun `retrieve with loader creates span with cache hit false when loader invoked`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache miss: delegate invokes the loader supplier
+    whenever(delegate.retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>()))
+      .thenAnswer { invocation ->
+        val loader = invocation.getArgument<Supplier<CompletableFuture<String>>>(1)
+        loader.get()
+      }
+
+    val result = wrapper.retrieve("myKey") { CompletableFuture.completedFuture("loaded") }
+
+    assertEquals("loaded", result.get())
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+    assertTrue(tx.spans.first().isFinished)
+  }
+
+  @Test
+  fun `retrieve with loader sets error status when future completes exceptionally`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("async loader error")
+    whenever(delegate.retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>()))
+      .thenReturn(CompletableFuture<String>().also { it.completeExceptionally(exception) })
+
+    val result = wrapper.retrieve("myKey") { CompletableFuture.completedFuture("loaded") }
+
+    assertFailsWith<Exception> { result.get() }
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve with loader does not create span when tracing is disabled`() {
+    options.isEnableCacheTracing = false
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>()))
+      .thenReturn(CompletableFuture.completedFuture("cached"))
+
+    wrapper.retrieve("myKey") { CompletableFuture.completedFuture("loaded") }
+
+    verify(delegate).retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>())
+    assertEquals(0, tx.spans.size)
+  }
+
+  // -- put --
+
+  @Test
+  fun `put creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    wrapper.put("myKey", "myValue")
+
+    verify(delegate).put("myKey", "myValue")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.put", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("put", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- putIfAbsent --
+
+  @Test
+  fun `putIfAbsent creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.putIfAbsent("myKey", "myValue")).thenReturn(null)
+
+    val result = wrapper.putIfAbsent("myKey", "myValue")
+
+    assertNull(result)
+    verify(delegate).putIfAbsent("myKey", "myValue")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.putIfAbsent", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("putIfAbsent", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- evict --
+
+  @Test
+  fun `evict creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    wrapper.evict("myKey")
+
+    verify(delegate).evict("myKey")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.evict", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("evict", span.getData(SpanDataConvention.CACHE_OPERATION))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- evictIfPresent --
+
+  @Test
+  fun `evictIfPresent creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.evictIfPresent("myKey")).thenReturn(true)
+
+    val result = wrapper.evictIfPresent("myKey")
+
+    assertTrue(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.evictIfPresent", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("evictIfPresent", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- clear --
+
+  @Test
+  fun `clear creates cache flush span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    wrapper.clear()
+
+    verify(delegate).clear()
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.clear", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertNull(span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("clear", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- invalidate --
+
+  @Test
+  fun `invalidate creates cache flush span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.invalidate()).thenReturn(true)
+
+    val result = wrapper.invalidate()
+
+    assertTrue(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.invalidate", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("invalidate", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  @Test
+  fun `invalidate sets cache write false when cache had no mappings`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.invalidate()).thenReturn(false)
+
+    val result = wrapper.invalidate()
+
+    assertFalse(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.invalidate", tx.spans.first().operation)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("invalidate", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- no span when no active transaction --
+
+  @Test
+  fun `does not create span when there is no active transaction`() {
+    whenever(scopes.span).thenReturn(null)
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    wrapper.get("myKey")
+
+    verify(delegate).get("myKey")
+  }
+
+  // -- no span when option is disabled --
+
+  @Test
+  fun `does not create span when enableCacheTracing is false`() {
+    options.isEnableCacheTracing = false
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    wrapper.get("myKey")
+
+    verify(delegate).get("myKey")
+    assertEquals(0, tx.spans.size)
+  }
+
+  // -- error handling --
+
+  @Test
+  fun `sets error status and throwable on exception`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("cache error")
+    whenever(delegate.get("myKey")).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { wrapper.get("myKey") }
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+  }
+
+  // -- delegation --
+
+  @Test
+  fun `getName delegates to underlying cache`() {
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    assertEquals("testCache", wrapper.name)
+  }
+
+  @Test
+  fun `getNativeCache delegates to underlying cache`() {
+    val nativeCache = Object()
+    whenever(delegate.nativeCache).thenReturn(nativeCache)
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    assertEquals(nativeCache, wrapper.nativeCache)
+  }
+}
diff --git a/sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryAutoConfiguration.java b/sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryAutoConfiguration.java
index 1b804e8cb8d..ae9e3ac50fe 100644
--- a/sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryAutoConfiguration.java
+++ b/sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryAutoConfiguration.java
@@ -25,6 +25,7 @@
 import io.sentry.spring7.SentryWebConfiguration;
 import io.sentry.spring7.SpringProfilesEventProcessor;
 import io.sentry.spring7.SpringSecuritySentryUserProvider;
+import io.sentry.spring7.cache.SentryCacheBeanPostProcessor;
 import io.sentry.spring7.checkin.SentryCheckInAdviceConfiguration;
 import io.sentry.spring7.checkin.SentryCheckInPointcutConfiguration;
 import io.sentry.spring7.checkin.SentryQuartzConfiguration;
@@ -65,6 +66,7 @@
 import org.springframework.boot.restclient.autoconfigure.RestTemplateAutoConfiguration;
 import org.springframework.boot.web.servlet.FilterRegistrationBean;
 import org.springframework.boot.webclient.autoconfigure.WebClientAutoConfiguration;
+import org.springframework.cache.CacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
@@ -229,6 +231,19 @@ static class Graphql22Configuration {}
     })
     static class QuartzConfiguration {}
 
+    @Configuration(proxyBeanMethods = false)
+    @ConditionalOnClass(CacheManager.class)
+    @ConditionalOnProperty(name = "sentry.enable-cache-tracing", havingValue = "true")
+    @Open
+    static class SentryCacheConfiguration {
+
+      @Bean
+      public static @NotNull SentryCacheBeanPostProcessor sentryCacheBeanPostProcessor() {
+        SentryIntegrationPackageStorage.getInstance().addIntegration("SpringCache");
+        return new SentryCacheBeanPostProcessor();
+      }
+    }
+
     @Configuration(proxyBeanMethods = false)
     @ConditionalOnClass(ProceedingJoinPoint.class)
     @ConditionalOnProperty(
diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt
index a5566ef2f30..7f30c860bb3 100644
--- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt
+++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt
@@ -38,6 +38,7 @@ import io.sentry.spring7.SentryUserFilter
 import io.sentry.spring7.SentryUserProvider
 import io.sentry.spring7.SpringProfilesEventProcessor
 import io.sentry.spring7.SpringSecuritySentryUserProvider
+import io.sentry.spring7.cache.SentryCacheBeanPostProcessor
 import io.sentry.spring7.tracing.SentryTracingFilter
 import io.sentry.spring7.tracing.SpringServletTransactionNameProvider
 import io.sentry.spring7.tracing.TransactionNameProvider
@@ -231,6 +232,7 @@ class SentryAutoConfigurationTest {
         "sentry.ignored-transactions=transactionName1,transactionNameB",
         "sentry.enable-backpressure-handling=false",
         "sentry.enable-database-transaction-tracing=true",
+        "sentry.enable-cache-tracing=true",
         "sentry.enable-spotlight=true",
         "sentry.spotlight-connection-url=http://local.sentry.io:1234",
         "sentry.force-init=true",
@@ -284,6 +286,7 @@ class SentryAutoConfigurationTest {
           .containsOnly(FilterString("transactionName1"), FilterString("transactionNameB"))
         assertThat(options.isEnableBackpressureHandling).isEqualTo(false)
         assertThat(options.isEnableDatabaseTransactionTracing).isEqualTo(true)
+        assertThat(options.isEnableCacheTracing).isEqualTo(true)
         assertThat(options.isForceInit).isEqualTo(true)
         assertThat(options.isGlobalHubMode).isEqualTo(true)
         assertThat(options.isCaptureOpenTelemetryEvents).isEqualTo(true)
@@ -1179,6 +1182,33 @@ class SentryAutoConfigurationTest {
       }
   }
 
+  @Test
+  fun `SentryCacheBeanPostProcessor is registered when enable-cache-tracing is true`() {
+    contextRunner
+      .withPropertyValues(
+        "sentry.dsn=http://key@localhost/proj",
+        "sentry.enable-cache-tracing=true",
+      )
+      .run { assertThat(it).hasSingleBean(SentryCacheBeanPostProcessor::class.java) }
+  }
+
+  @Test
+  fun `SentryCacheBeanPostProcessor is not registered when enable-cache-tracing is missing`() {
+    contextRunner.withPropertyValues("sentry.dsn=http://key@localhost/proj").run {
+      assertThat(it).doesNotHaveBean(SentryCacheBeanPostProcessor::class.java)
+    }
+  }
+
+  @Test
+  fun `SentryCacheBeanPostProcessor is not registered when enable-cache-tracing is false`() {
+    contextRunner
+      .withPropertyValues(
+        "sentry.dsn=http://key@localhost/proj",
+        "sentry.enable-cache-tracing=false",
+      )
+      .run { assertThat(it).doesNotHaveBean(SentryCacheBeanPostProcessor::class.java) }
+  }
+
   @Configuration(proxyBeanMethods = false)
   open class CustomSchedulerFactoryBeanCustomizerConfiguration {
     class MyJobListener : JobListener {
diff --git a/sentry-spring-boot-jakarta/src/main/java/io/sentry/spring/boot/jakarta/SentryAutoConfiguration.java b/sentry-spring-boot-jakarta/src/main/java/io/sentry/spring/boot/jakarta/SentryAutoConfiguration.java
index 8663dac8c56..ef57868ad87 100644
--- a/sentry-spring-boot-jakarta/src/main/java/io/sentry/spring/boot/jakarta/SentryAutoConfiguration.java
+++ b/sentry-spring-boot-jakarta/src/main/java/io/sentry/spring/boot/jakarta/SentryAutoConfiguration.java
@@ -25,6 +25,7 @@
 import io.sentry.spring.jakarta.SentryWebConfiguration;
 import io.sentry.spring.jakarta.SpringProfilesEventProcessor;
 import io.sentry.spring.jakarta.SpringSecuritySentryUserProvider;
+import io.sentry.spring.jakarta.cache.SentryCacheBeanPostProcessor;
 import io.sentry.spring.jakarta.checkin.SentryCheckInAdviceConfiguration;
 import io.sentry.spring.jakarta.checkin.SentryCheckInPointcutConfiguration;
 import io.sentry.spring.jakarta.checkin.SentryQuartzConfiguration;
@@ -65,6 +66,7 @@
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.boot.info.GitProperties;
 import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.cache.CacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
@@ -231,6 +233,19 @@ static class Graphql22Configuration {}
     })
     static class QuartzConfiguration {}
 
+    @Configuration(proxyBeanMethods = false)
+    @ConditionalOnClass(CacheManager.class)
+    @ConditionalOnProperty(name = "sentry.enable-cache-tracing", havingValue = "true")
+    @Open
+    static class SentryCacheConfiguration {
+
+      @Bean
+      public static @NotNull SentryCacheBeanPostProcessor sentryCacheBeanPostProcessor() {
+        SentryIntegrationPackageStorage.getInstance().addIntegration("SpringCache");
+        return new SentryCacheBeanPostProcessor();
+      }
+    }
+
     @Configuration(proxyBeanMethods = false)
     @ConditionalOnClass(ProceedingJoinPoint.class)
     @ConditionalOnProperty(
diff --git a/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java b/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java
index 76424b5c55f..99fd602f74b 100644
--- a/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java
+++ b/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java
@@ -25,6 +25,7 @@
 import io.sentry.spring.SpringProfilesEventProcessor;
 import io.sentry.spring.SpringSecuritySentryUserProvider;
 import io.sentry.spring.boot.graphql.SentryGraphqlAutoConfiguration;
+import io.sentry.spring.cache.SentryCacheBeanPostProcessor;
 import io.sentry.spring.checkin.SentryCheckInAdviceConfiguration;
 import io.sentry.spring.checkin.SentryCheckInPointcutConfiguration;
 import io.sentry.spring.checkin.SentryQuartzConfiguration;
@@ -64,6 +65,7 @@
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.boot.info.GitProperties;
 import org.springframework.boot.web.servlet.FilterRegistrationBean;
+import org.springframework.cache.CacheManager;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Conditional;
 import org.springframework.context.annotation.Configuration;
@@ -216,6 +218,19 @@ static class GraphqlConfiguration {}
     })
     static class QuartzConfiguration {}
 
+    @Configuration(proxyBeanMethods = false)
+    @ConditionalOnClass(CacheManager.class)
+    @ConditionalOnProperty(name = "sentry.enable-cache-tracing", havingValue = "true")
+    @Open
+    static class SentryCacheConfiguration {
+
+      @Bean
+      public static @NotNull SentryCacheBeanPostProcessor sentryCacheBeanPostProcessor() {
+        SentryIntegrationPackageStorage.getInstance().addIntegration("SpringCache");
+        return new SentryCacheBeanPostProcessor();
+      }
+    }
+
     @Configuration(proxyBeanMethods = false)
     @ConditionalOnClass(ProceedingJoinPoint.class)
     @ConditionalOnProperty(
diff --git a/sentry-spring-jakarta/api/sentry-spring-jakarta.api b/sentry-spring-jakarta/api/sentry-spring-jakarta.api
index f28f4153b59..fe634da6f4c 100644
--- a/sentry-spring-jakarta/api/sentry-spring-jakarta.api
+++ b/sentry-spring-jakarta/api/sentry-spring-jakarta.api
@@ -104,6 +104,35 @@ public final class io/sentry/spring/jakarta/SpringSecuritySentryUserProvider : i
 	public fun provideUser ()Lio/sentry/protocol/User;
 }
 
+public final class io/sentry/spring/jakarta/cache/SentryCacheBeanPostProcessor : org/springframework/beans/factory/config/BeanPostProcessor, org/springframework/core/PriorityOrdered {
+	public fun <init> ()V
+	public fun getOrder ()I
+	public fun postProcessAfterInitialization (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class io/sentry/spring/jakarta/cache/SentryCacheManagerWrapper : org/springframework/cache/CacheManager {
+	public fun <init> (Lorg/springframework/cache/CacheManager;Lio/sentry/IScopes;)V
+	public fun getCache (Ljava/lang/String;)Lorg/springframework/cache/Cache;
+	public fun getCacheNames ()Ljava/util/Collection;
+}
+
+public final class io/sentry/spring/jakarta/cache/SentryCacheWrapper : org/springframework/cache/Cache {
+	public fun <init> (Lorg/springframework/cache/Cache;Lio/sentry/IScopes;)V
+	public fun clear ()V
+	public fun evict (Ljava/lang/Object;)V
+	public fun evictIfPresent (Ljava/lang/Object;)Z
+	public fun get (Ljava/lang/Object;)Lorg/springframework/cache/Cache$ValueWrapper;
+	public fun get (Ljava/lang/Object;Ljava/lang/Class;)Ljava/lang/Object;
+	public fun get (Ljava/lang/Object;Ljava/util/concurrent/Callable;)Ljava/lang/Object;
+	public fun getName ()Ljava/lang/String;
+	public fun getNativeCache ()Ljava/lang/Object;
+	public fun invalidate ()Z
+	public fun put (Ljava/lang/Object;Ljava/lang/Object;)V
+	public fun putIfAbsent (Ljava/lang/Object;Ljava/lang/Object;)Lorg/springframework/cache/Cache$ValueWrapper;
+	public fun retrieve (Ljava/lang/Object;)Ljava/util/concurrent/CompletableFuture;
+	public fun retrieve (Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/util/concurrent/CompletableFuture;
+}
+
 public abstract interface annotation class io/sentry/spring/jakarta/checkin/SentryCheckIn : java/lang/annotation/Annotation {
 	public abstract fun heartbeat ()Z
 	public abstract fun monitorSlug ()Ljava/lang/String;
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheBeanPostProcessor.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheBeanPostProcessor.java
new file mode 100644
index 00000000000..ec9964f7abc
--- /dev/null
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheBeanPostProcessor.java
@@ -0,0 +1,29 @@
+package io.sentry.spring.jakarta.cache;
+
+import io.sentry.ScopesAdapter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.cache.CacheManager;
+import org.springframework.core.Ordered;
+import org.springframework.core.PriorityOrdered;
+
+/** Wraps {@link CacheManager} beans in {@link SentryCacheManagerWrapper} for instrumentation. */
+@ApiStatus.Internal
+public final class SentryCacheBeanPostProcessor implements BeanPostProcessor, PriorityOrdered {
+
+  @Override
+  public @NotNull Object postProcessAfterInitialization(
+      final @NotNull Object bean, final @NotNull String beanName) throws BeansException {
+    if (bean instanceof CacheManager && !(bean instanceof SentryCacheManagerWrapper)) {
+      return new SentryCacheManagerWrapper((CacheManager) bean, ScopesAdapter.getInstance());
+    }
+    return bean;
+  }
+
+  @Override
+  public int getOrder() {
+    return Ordered.LOWEST_PRECEDENCE;
+  }
+}
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheManagerWrapper.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheManagerWrapper.java
new file mode 100644
index 00000000000..ed243e973a2
--- /dev/null
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheManagerWrapper.java
@@ -0,0 +1,37 @@
+package io.sentry.spring.jakarta.cache;
+
+import io.sentry.IScopes;
+import java.util.Collection;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+
+/** Wraps a Spring {@link CacheManager} to return Sentry-instrumented caches. */
+@ApiStatus.Internal
+public final class SentryCacheManagerWrapper implements CacheManager {
+
+  private final @NotNull CacheManager delegate;
+  private final @NotNull IScopes scopes;
+
+  public SentryCacheManagerWrapper(
+      final @NotNull CacheManager delegate, final @NotNull IScopes scopes) {
+    this.delegate = delegate;
+    this.scopes = scopes;
+  }
+
+  @Override
+  public @Nullable Cache getCache(final @NotNull String name) {
+    final Cache cache = delegate.getCache(name);
+    if (cache == null || cache instanceof SentryCacheWrapper) {
+      return cache;
+    }
+    return new SentryCacheWrapper(cache, scopes);
+  }
+
+  @Override
+  public @NotNull Collection<String> getCacheNames() {
+    return delegate.getCacheNames();
+  }
+}
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheWrapper.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheWrapper.java
new file mode 100644
index 00000000000..9b7c551a2d2
--- /dev/null
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/cache/SentryCacheWrapper.java
@@ -0,0 +1,326 @@
+package io.sentry.spring.jakarta.cache;
+
+import io.sentry.IScopes;
+import io.sentry.ISpan;
+import io.sentry.SpanDataConvention;
+import io.sentry.SpanOptions;
+import io.sentry.SpanStatus;
+import java.util.Collections;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.cache.Cache;
+
+/** Wraps a Spring {@link Cache} to create Sentry spans for cache operations. */
+@ApiStatus.Internal
+public final class SentryCacheWrapper implements Cache {
+
+  private static final String TRACE_ORIGIN = "auto.cache.spring";
+
+  private final @NotNull Cache delegate;
+  private final @NotNull IScopes scopes;
+
+  public SentryCacheWrapper(final @NotNull Cache delegate, final @NotNull IScopes scopes) {
+    this.delegate = delegate;
+    this.scopes = scopes;
+  }
+
+  @Override
+  public @NotNull String getName() {
+    return delegate.getName();
+  }
+
+  @Override
+  public @NotNull Object getNativeCache() {
+    return delegate.getNativeCache();
+  }
+
+  @Override
+  public @Nullable ValueWrapper get(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key);
+    }
+    try {
+      final ValueWrapper result = delegate.get(key);
+      span.setData(SpanDataConvention.CACHE_HIT, result != null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable <T> T get(final @NotNull Object key, final @Nullable Class<T> type) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key, type);
+    }
+    try {
+      final T result = delegate.get(key, type);
+      span.setData(SpanDataConvention.CACHE_HIT, result != null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable <T> T get(final @NotNull Object key, final @NotNull Callable<T> valueLoader) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key, valueLoader);
+    }
+    try {
+      final AtomicBoolean loaderInvoked = new AtomicBoolean(false);
+      final T result =
+          delegate.get(
+              key,
+              () -> {
+                loaderInvoked.set(true);
+                return valueLoader.call();
+              });
+      span.setData(SpanDataConvention.CACHE_HIT, !loaderInvoked.get());
+      span.setData(SpanDataConvention.CACHE_WRITE, loaderInvoked.get());
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable CompletableFuture<?> retrieve(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "retrieve");
+    if (span == null) {
+      return delegate.retrieve(key);
+    }
+    final CompletableFuture<?> result;
+    try {
+      result = delegate.retrieve(key);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      span.finish();
+      throw e;
+    }
+    if (result == null) {
+      span.setData(SpanDataConvention.CACHE_HIT, false);
+      span.setStatus(SpanStatus.OK);
+      span.finish();
+      return null;
+    }
+    return result.whenComplete(
+        (value, throwable) -> {
+          if (throwable != null) {
+            span.setStatus(SpanStatus.INTERNAL_ERROR);
+            span.setThrowable(throwable);
+          } else {
+            span.setData(SpanDataConvention.CACHE_HIT, value != null);
+            span.setStatus(SpanStatus.OK);
+          }
+          span.finish();
+        });
+  }
+
+  @Override
+  public <T> CompletableFuture<T> retrieve(
+      final @NotNull Object key, final @NotNull Supplier<CompletableFuture<T>> valueLoader) {
+    final ISpan span = startSpan(key, "retrieve");
+    if (span == null) {
+      return delegate.retrieve(key, valueLoader);
+    }
+    final AtomicBoolean loaderInvoked = new AtomicBoolean(false);
+    final CompletableFuture<T> result;
+    try {
+      result =
+          delegate.retrieve(
+              key,
+              () -> {
+                loaderInvoked.set(true);
+                return valueLoader.get();
+              });
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      span.finish();
+      throw e;
+    }
+    return result.whenComplete(
+        (value, throwable) -> {
+          if (throwable != null) {
+            span.setStatus(SpanStatus.INTERNAL_ERROR);
+            span.setThrowable(throwable);
+          } else {
+            span.setData(SpanDataConvention.CACHE_HIT, !loaderInvoked.get());
+            span.setData(SpanDataConvention.CACHE_WRITE, loaderInvoked.get());
+            span.setStatus(SpanStatus.OK);
+          }
+          span.finish();
+        });
+  }
+
+  @Override
+  public void put(final @NotNull Object key, final @Nullable Object value) {
+    final ISpan span = startSpan(key, "put");
+    if (span == null) {
+      delegate.put(key, value);
+      return;
+    }
+    try {
+      delegate.put(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable ValueWrapper putIfAbsent(
+      final @NotNull Object key, final @Nullable Object value) {
+    final ISpan span = startSpan(key, "putIfAbsent");
+    if (span == null) {
+      return delegate.putIfAbsent(key, value);
+    }
+    try {
+      final ValueWrapper result = delegate.putIfAbsent(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, result == null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void evict(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "evict");
+    if (span == null) {
+      delegate.evict(key);
+      return;
+    }
+    try {
+      delegate.evict(key);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean evictIfPresent(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "evictIfPresent");
+    if (span == null) {
+      return delegate.evictIfPresent(key);
+    }
+    try {
+      final boolean result = delegate.evictIfPresent(key);
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void clear() {
+    final ISpan span = startSpan(null, "clear");
+    if (span == null) {
+      delegate.clear();
+      return;
+    }
+    try {
+      delegate.clear();
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean invalidate() {
+    final ISpan span = startSpan(null, "invalidate");
+    if (span == null) {
+      return delegate.invalidate();
+    }
+    try {
+      final boolean result = delegate.invalidate();
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  private @Nullable ISpan startSpan(
+      final @Nullable Object key, final @NotNull String operationName) {
+    if (!scopes.getOptions().isEnableCacheTracing()) {
+      return null;
+    }
+
+    final ISpan activeSpan = scopes.getSpan();
+    if (activeSpan == null || activeSpan.isNoOp()) {
+      return null;
+    }
+
+    final SpanOptions spanOptions = new SpanOptions();
+    spanOptions.setOrigin(TRACE_ORIGIN);
+    final String keyString = key != null ? String.valueOf(key) : null;
+    final ISpan span = activeSpan.startChild("cache." + operationName, keyString, spanOptions);
+    if (span.isNoOp()) {
+      return null;
+    }
+    if (keyString != null) {
+      span.setData(SpanDataConvention.CACHE_KEY, Collections.singletonList(keyString));
+    }
+    span.setData(SpanDataConvention.CACHE_OPERATION, operationName);
+    return span;
+  }
+}
diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheBeanPostProcessorTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheBeanPostProcessorTest.kt
new file mode 100644
index 00000000000..301678d35d9
--- /dev/null
+++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheBeanPostProcessorTest.kt
@@ -0,0 +1,44 @@
+package io.sentry.spring.jakarta.cache
+
+import io.sentry.IScopes
+import kotlin.test.Test
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.springframework.cache.CacheManager
+
+class SentryCacheBeanPostProcessorTest {
+
+  private val scopes: IScopes = mock()
+
+  @Test
+  fun `wraps CacheManager beans in SentryCacheManagerWrapper`() {
+    val cacheManager = mock<CacheManager>()
+    val processor = SentryCacheBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(cacheManager, "cacheManager")
+
+    assertTrue(result is SentryCacheManagerWrapper)
+  }
+
+  @Test
+  fun `does not double-wrap SentryCacheManagerWrapper`() {
+    val delegate = mock<CacheManager>()
+    val alreadyWrapped = SentryCacheManagerWrapper(delegate, scopes)
+    val processor = SentryCacheBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(alreadyWrapped, "cacheManager")
+
+    assertSame(alreadyWrapped, result)
+  }
+
+  @Test
+  fun `does not wrap non-CacheManager beans`() {
+    val someBean = "not a cache manager"
+    val processor = SentryCacheBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(someBean, "someBean")
+
+    assertSame(someBean, result)
+  }
+}
diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheManagerWrapperTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheManagerWrapperTest.kt
new file mode 100644
index 00000000000..05daa207d37
--- /dev/null
+++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheManagerWrapperTest.kt
@@ -0,0 +1,61 @@
+package io.sentry.spring.jakarta.cache
+
+import io.sentry.IScopes
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+import org.springframework.cache.Cache
+import org.springframework.cache.CacheManager
+
+class SentryCacheManagerWrapperTest {
+
+  private val scopes: IScopes = mock()
+  private val delegate: CacheManager = mock()
+
+  @Test
+  fun `getCache wraps returned cache in SentryCacheWrapper`() {
+    val cache = mock<Cache>()
+    whenever(delegate.getCache("test")).thenReturn(cache)
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.getCache("test")
+
+    assertTrue(result is SentryCacheWrapper)
+  }
+
+  @Test
+  fun `getCache returns null when delegate returns null`() {
+    whenever(delegate.getCache("missing")).thenReturn(null)
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.getCache("missing")
+
+    assertNull(result)
+  }
+
+  @Test
+  fun `getCache does not double-wrap SentryCacheWrapper`() {
+    val innerCache = mock<Cache>()
+    val alreadyWrapped = SentryCacheWrapper(innerCache, scopes)
+    whenever(delegate.getCache("test")).thenReturn(alreadyWrapped)
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.getCache("test")
+
+    assertSame(alreadyWrapped, result)
+  }
+
+  @Test
+  fun `getCacheNames delegates to underlying cache manager`() {
+    whenever(delegate.cacheNames).thenReturn(listOf("cache1", "cache2"))
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.cacheNames
+
+    assertEquals(listOf("cache1", "cache2"), result)
+  }
+}
diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheWrapperTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheWrapperTest.kt
new file mode 100644
index 00000000000..a04f548d447
--- /dev/null
+++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/cache/SentryCacheWrapperTest.kt
@@ -0,0 +1,530 @@
+package io.sentry.spring.jakarta.cache
+
+import io.sentry.IScopes
+import io.sentry.SentryOptions
+import io.sentry.SentryTracer
+import io.sentry.SpanDataConvention
+import io.sentry.SpanStatus
+import io.sentry.TransactionContext
+import java.util.concurrent.Callable
+import java.util.concurrent.CompletableFuture
+import java.util.function.Supplier
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.springframework.cache.Cache
+
+class SentryCacheWrapperTest {
+
+  private lateinit var scopes: IScopes
+  private lateinit var delegate: Cache
+  private lateinit var options: SentryOptions
+
+  @BeforeTest
+  fun setup() {
+    scopes = mock()
+    delegate = mock()
+    options = SentryOptions().apply { isEnableCacheTracing = true }
+    whenever(scopes.options).thenReturn(options)
+    whenever(delegate.name).thenReturn("testCache")
+  }
+
+  private fun createTransaction(): SentryTracer {
+    val tx = SentryTracer(TransactionContext("tx", "op"), scopes)
+    whenever(scopes.span).thenReturn(tx)
+    return tx
+  }
+
+  // -- get(Object key) --
+
+  @Test
+  fun `get with ValueWrapper creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val valueWrapper = mock<Cache.ValueWrapper>()
+    whenever(delegate.get("myKey")).thenReturn(valueWrapper)
+
+    val result = wrapper.get("myKey")
+
+    assertEquals(valueWrapper, result)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.get", span.operation)
+    assertEquals("myKey", span.description)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_HIT))
+    assertNull(span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("auto.cache.spring", span.spanContext.origin)
+    assertEquals("get", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  @Test
+  fun `get with ValueWrapper creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    val result = wrapper.get("myKey")
+
+    assertNull(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- get(Object key, Class<T>) --
+
+  @Test
+  fun `get with type creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey", String::class.java)).thenReturn("value")
+
+    val result = wrapper.get("myKey", String::class.java)
+
+    assertEquals("value", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  @Test
+  fun `get with type creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey", String::class.java)).thenReturn(null)
+
+    val result = wrapper.get("myKey", String::class.java)
+
+    assertNull(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  @Test
+  fun `get with type sets error status and throwable on exception`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("cache error")
+    whenever(delegate.get("myKey", String::class.java)).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { wrapper.get("myKey", String::class.java) }
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+  }
+
+  // -- get(Object key, Callable<T>) --
+
+  @Test
+  fun `get with callable creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache hit: delegate returns value without invoking the loader
+    whenever(delegate.get(eq("myKey"), any<Callable<String>>())).thenReturn("cached")
+
+    val result = wrapper.get("myKey", Callable { "loaded" })
+
+    assertEquals("cached", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  @Test
+  fun `get with callable creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache miss: delegate invokes the loader callable
+    whenever(delegate.get(eq("myKey"), any<Callable<String>>())).thenAnswer { invocation ->
+      val loader = invocation.getArgument<Callable<String>>(1)
+      loader.call()
+    }
+
+    val result = wrapper.get("myKey", Callable { "loaded" })
+
+    assertEquals("loaded", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- retrieve(Object key) --
+
+  @Test
+  fun `retrieve creates span with cache hit true when future resolves with value`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve("myKey")).thenReturn(CompletableFuture.completedFuture("value"))
+
+    val result = wrapper.retrieve("myKey")
+
+    assertEquals("value", result!!.get())
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.retrieve", span.operation)
+    assertEquals("myKey", span.description)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_HIT))
+    assertNull(span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("retrieve", span.getData(SpanDataConvention.CACHE_OPERATION))
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve creates span with cache hit false when future resolves with null`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve("myKey")).thenReturn(CompletableFuture.completedFuture(null))
+
+    val result = wrapper.retrieve("myKey")
+
+    assertNull(result!!.get())
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+    assertTrue(tx.spans.first().isFinished)
+  }
+
+  @Test
+  fun `retrieve creates span with cache hit false when delegate returns null`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve("myKey")).thenReturn(null)
+
+    val result = wrapper.retrieve("myKey")
+
+    assertNull(result)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(false, span.getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals(SpanStatus.OK, span.status)
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve sets error status when future completes exceptionally`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("async cache error")
+    whenever(delegate.retrieve("myKey"))
+      .thenReturn(CompletableFuture<Any>().also { it.completeExceptionally(exception) })
+
+    val result = wrapper.retrieve("myKey")
+
+    assertFailsWith<Exception> { result!!.get() }
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve sets error status when delegate throws synchronously`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("sync error")
+    whenever(delegate.retrieve("myKey")).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { wrapper.retrieve("myKey") }
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve does not create span when tracing is disabled`() {
+    options.isEnableCacheTracing = false
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve("myKey")).thenReturn(CompletableFuture.completedFuture("value"))
+
+    wrapper.retrieve("myKey")
+
+    verify(delegate).retrieve("myKey")
+    assertEquals(0, tx.spans.size)
+  }
+
+  // -- retrieve(Object key, Supplier<CompletableFuture<T>>) --
+
+  @Test
+  fun `retrieve with loader creates span with cache hit true when loader not invoked`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache hit: delegate returns value without invoking the loader
+    whenever(delegate.retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>()))
+      .thenReturn(CompletableFuture.completedFuture("cached"))
+
+    val result = wrapper.retrieve("myKey") { CompletableFuture.completedFuture("loaded") }
+
+    assertEquals("cached", result.get())
+    assertEquals(1, tx.spans.size)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+    assertTrue(tx.spans.first().isFinished)
+  }
+
+  @Test
+  fun `retrieve with loader creates span with cache hit false when loader invoked`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache miss: delegate invokes the loader supplier
+    whenever(delegate.retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>()))
+      .thenAnswer { invocation ->
+        val loader = invocation.getArgument<Supplier<CompletableFuture<String>>>(1)
+        loader.get()
+      }
+
+    val result = wrapper.retrieve("myKey") { CompletableFuture.completedFuture("loaded") }
+
+    assertEquals("loaded", result.get())
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+    assertTrue(tx.spans.first().isFinished)
+  }
+
+  @Test
+  fun `retrieve with loader sets error status when future completes exceptionally`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("async loader error")
+    whenever(delegate.retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>()))
+      .thenReturn(CompletableFuture<String>().also { it.completeExceptionally(exception) })
+
+    val result = wrapper.retrieve("myKey") { CompletableFuture.completedFuture("loaded") }
+
+    assertFailsWith<Exception> { result.get() }
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `retrieve with loader does not create span when tracing is disabled`() {
+    options.isEnableCacheTracing = false
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>()))
+      .thenReturn(CompletableFuture.completedFuture("cached"))
+
+    wrapper.retrieve("myKey") { CompletableFuture.completedFuture("loaded") }
+
+    verify(delegate).retrieve(eq("myKey"), any<Supplier<CompletableFuture<String>>>())
+    assertEquals(0, tx.spans.size)
+  }
+
+  // -- put --
+
+  @Test
+  fun `put creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    wrapper.put("myKey", "myValue")
+
+    verify(delegate).put("myKey", "myValue")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.put", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("put", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- putIfAbsent --
+
+  @Test
+  fun `putIfAbsent creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.putIfAbsent("myKey", "myValue")).thenReturn(null)
+
+    val result = wrapper.putIfAbsent("myKey", "myValue")
+
+    assertNull(result)
+    verify(delegate).putIfAbsent("myKey", "myValue")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.putIfAbsent", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("putIfAbsent", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- evict --
+
+  @Test
+  fun `evict creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    wrapper.evict("myKey")
+
+    verify(delegate).evict("myKey")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.evict", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("evict", span.getData(SpanDataConvention.CACHE_OPERATION))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- evictIfPresent --
+
+  @Test
+  fun `evictIfPresent creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.evictIfPresent("myKey")).thenReturn(true)
+
+    val result = wrapper.evictIfPresent("myKey")
+
+    assertTrue(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.evictIfPresent", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("evictIfPresent", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- clear --
+
+  @Test
+  fun `clear creates cache flush span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    wrapper.clear()
+
+    verify(delegate).clear()
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.clear", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertNull(span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("clear", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- invalidate --
+
+  @Test
+  fun `invalidate creates cache flush span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.invalidate()).thenReturn(true)
+
+    val result = wrapper.invalidate()
+
+    assertTrue(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.invalidate", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("invalidate", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  @Test
+  fun `invalidate sets cache write false when cache had no mappings`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.invalidate()).thenReturn(false)
+
+    val result = wrapper.invalidate()
+
+    assertFalse(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.invalidate", tx.spans.first().operation)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("invalidate", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- no span when no active transaction --
+
+  @Test
+  fun `does not create span when there is no active transaction`() {
+    whenever(scopes.span).thenReturn(null)
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    wrapper.get("myKey")
+
+    verify(delegate).get("myKey")
+  }
+
+  // -- no span when option is disabled --
+
+  @Test
+  fun `does not create span when enableCacheTracing is false`() {
+    options.isEnableCacheTracing = false
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    wrapper.get("myKey")
+
+    verify(delegate).get("myKey")
+    assertEquals(0, tx.spans.size)
+  }
+
+  // -- error handling --
+
+  @Test
+  fun `sets error status and throwable on exception`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("cache error")
+    whenever(delegate.get("myKey")).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { wrapper.get("myKey") }
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+  }
+
+  // -- delegation --
+
+  @Test
+  fun `getName delegates to underlying cache`() {
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    assertEquals("testCache", wrapper.name)
+  }
+
+  @Test
+  fun `getNativeCache delegates to underlying cache`() {
+    val nativeCache = Object()
+    whenever(delegate.nativeCache).thenReturn(nativeCache)
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    assertEquals(nativeCache, wrapper.nativeCache)
+  }
+}
diff --git a/sentry-spring/api/sentry-spring.api b/sentry-spring/api/sentry-spring.api
index fb07af382ba..7148277e2ef 100644
--- a/sentry-spring/api/sentry-spring.api
+++ b/sentry-spring/api/sentry-spring.api
@@ -104,6 +104,33 @@ public final class io/sentry/spring/SpringSecuritySentryUserProvider : io/sentry
 	public fun provideUser ()Lio/sentry/protocol/User;
 }
 
+public final class io/sentry/spring/cache/SentryCacheBeanPostProcessor : org/springframework/beans/factory/config/BeanPostProcessor, org/springframework/core/PriorityOrdered {
+	public fun <init> ()V
+	public fun getOrder ()I
+	public fun postProcessAfterInitialization (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class io/sentry/spring/cache/SentryCacheManagerWrapper : org/springframework/cache/CacheManager {
+	public fun <init> (Lorg/springframework/cache/CacheManager;Lio/sentry/IScopes;)V
+	public fun getCache (Ljava/lang/String;)Lorg/springframework/cache/Cache;
+	public fun getCacheNames ()Ljava/util/Collection;
+}
+
+public final class io/sentry/spring/cache/SentryCacheWrapper : org/springframework/cache/Cache {
+	public fun <init> (Lorg/springframework/cache/Cache;Lio/sentry/IScopes;)V
+	public fun clear ()V
+	public fun evict (Ljava/lang/Object;)V
+	public fun evictIfPresent (Ljava/lang/Object;)Z
+	public fun get (Ljava/lang/Object;)Lorg/springframework/cache/Cache$ValueWrapper;
+	public fun get (Ljava/lang/Object;Ljava/lang/Class;)Ljava/lang/Object;
+	public fun get (Ljava/lang/Object;Ljava/util/concurrent/Callable;)Ljava/lang/Object;
+	public fun getName ()Ljava/lang/String;
+	public fun getNativeCache ()Ljava/lang/Object;
+	public fun invalidate ()Z
+	public fun put (Ljava/lang/Object;Ljava/lang/Object;)V
+	public fun putIfAbsent (Ljava/lang/Object;Ljava/lang/Object;)Lorg/springframework/cache/Cache$ValueWrapper;
+}
+
 public abstract interface annotation class io/sentry/spring/checkin/SentryCheckIn : java/lang/annotation/Annotation {
 	public abstract fun heartbeat ()Z
 	public abstract fun monitorSlug ()Ljava/lang/String;
diff --git a/sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheBeanPostProcessor.java b/sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheBeanPostProcessor.java
new file mode 100644
index 00000000000..7382f7500f2
--- /dev/null
+++ b/sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheBeanPostProcessor.java
@@ -0,0 +1,29 @@
+package io.sentry.spring.cache;
+
+import io.sentry.ScopesAdapter;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.cache.CacheManager;
+import org.springframework.core.Ordered;
+import org.springframework.core.PriorityOrdered;
+
+/** Wraps {@link CacheManager} beans in {@link SentryCacheManagerWrapper} for instrumentation. */
+@ApiStatus.Internal
+public final class SentryCacheBeanPostProcessor implements BeanPostProcessor, PriorityOrdered {
+
+  @Override
+  public @NotNull Object postProcessAfterInitialization(
+      final @NotNull Object bean, final @NotNull String beanName) throws BeansException {
+    if (bean instanceof CacheManager && !(bean instanceof SentryCacheManagerWrapper)) {
+      return new SentryCacheManagerWrapper((CacheManager) bean, ScopesAdapter.getInstance());
+    }
+    return bean;
+  }
+
+  @Override
+  public int getOrder() {
+    return Ordered.LOWEST_PRECEDENCE;
+  }
+}
diff --git a/sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheManagerWrapper.java b/sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheManagerWrapper.java
new file mode 100644
index 00000000000..a66517fd7fb
--- /dev/null
+++ b/sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheManagerWrapper.java
@@ -0,0 +1,37 @@
+package io.sentry.spring.cache;
+
+import io.sentry.IScopes;
+import java.util.Collection;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.cache.Cache;
+import org.springframework.cache.CacheManager;
+
+/** Wraps a Spring {@link CacheManager} to return Sentry-instrumented caches. */
+@ApiStatus.Internal
+public final class SentryCacheManagerWrapper implements CacheManager {
+
+  private final @NotNull CacheManager delegate;
+  private final @NotNull IScopes scopes;
+
+  public SentryCacheManagerWrapper(
+      final @NotNull CacheManager delegate, final @NotNull IScopes scopes) {
+    this.delegate = delegate;
+    this.scopes = scopes;
+  }
+
+  @Override
+  public @Nullable Cache getCache(final @NotNull String name) {
+    final Cache cache = delegate.getCache(name);
+    if (cache == null || cache instanceof SentryCacheWrapper) {
+      return cache;
+    }
+    return new SentryCacheWrapper(cache, scopes);
+  }
+
+  @Override
+  public @NotNull Collection<String> getCacheNames() {
+    return delegate.getCacheNames();
+  }
+}
diff --git a/sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheWrapper.java b/sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheWrapper.java
new file mode 100644
index 00000000000..0e0ccb7d228
--- /dev/null
+++ b/sentry-spring/src/main/java/io/sentry/spring/cache/SentryCacheWrapper.java
@@ -0,0 +1,253 @@
+package io.sentry.spring.cache;
+
+import io.sentry.IScopes;
+import io.sentry.ISpan;
+import io.sentry.SpanDataConvention;
+import io.sentry.SpanOptions;
+import io.sentry.SpanStatus;
+import java.util.Collections;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.cache.Cache;
+
+/** Wraps a Spring {@link Cache} to create Sentry spans for cache operations. */
+@ApiStatus.Internal
+public final class SentryCacheWrapper implements Cache {
+
+  private static final String TRACE_ORIGIN = "auto.cache.spring";
+
+  private final @NotNull Cache delegate;
+  private final @NotNull IScopes scopes;
+
+  public SentryCacheWrapper(final @NotNull Cache delegate, final @NotNull IScopes scopes) {
+    this.delegate = delegate;
+    this.scopes = scopes;
+  }
+
+  @Override
+  public @NotNull String getName() {
+    return delegate.getName();
+  }
+
+  @Override
+  public @NotNull Object getNativeCache() {
+    return delegate.getNativeCache();
+  }
+
+  @Override
+  public @Nullable ValueWrapper get(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key);
+    }
+    try {
+      final ValueWrapper result = delegate.get(key);
+      span.setData(SpanDataConvention.CACHE_HIT, result != null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable <T> T get(final @NotNull Object key, final @Nullable Class<T> type) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key, type);
+    }
+    try {
+      final T result = delegate.get(key, type);
+      span.setData(SpanDataConvention.CACHE_HIT, result != null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable <T> T get(final @NotNull Object key, final @NotNull Callable<T> valueLoader) {
+    final ISpan span = startSpan(key, "get");
+    if (span == null) {
+      return delegate.get(key, valueLoader);
+    }
+    try {
+      final AtomicBoolean loaderInvoked = new AtomicBoolean(false);
+      final T result =
+          delegate.get(
+              key,
+              () -> {
+                loaderInvoked.set(true);
+                return valueLoader.call();
+              });
+      span.setData(SpanDataConvention.CACHE_HIT, !loaderInvoked.get());
+      span.setData(SpanDataConvention.CACHE_WRITE, loaderInvoked.get());
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void put(final @NotNull Object key, final @Nullable Object value) {
+    final ISpan span = startSpan(key, "put");
+    if (span == null) {
+      delegate.put(key, value);
+      return;
+    }
+    try {
+      delegate.put(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public @Nullable ValueWrapper putIfAbsent(
+      final @NotNull Object key, final @Nullable Object value) {
+    final ISpan span = startSpan(key, "putIfAbsent");
+    if (span == null) {
+      return delegate.putIfAbsent(key, value);
+    }
+    try {
+      final ValueWrapper result = delegate.putIfAbsent(key, value);
+      span.setData(SpanDataConvention.CACHE_WRITE, result == null);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void evict(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "evict");
+    if (span == null) {
+      delegate.evict(key);
+      return;
+    }
+    try {
+      delegate.evict(key);
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean evictIfPresent(final @NotNull Object key) {
+    final ISpan span = startSpan(key, "evictIfPresent");
+    if (span == null) {
+      return delegate.evictIfPresent(key);
+    }
+    try {
+      final boolean result = delegate.evictIfPresent(key);
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public void clear() {
+    final ISpan span = startSpan(null, "clear");
+    if (span == null) {
+      delegate.clear();
+      return;
+    }
+    try {
+      delegate.clear();
+      span.setData(SpanDataConvention.CACHE_WRITE, true);
+      span.setStatus(SpanStatus.OK);
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  @Override
+  public boolean invalidate() {
+    final ISpan span = startSpan(null, "invalidate");
+    if (span == null) {
+      return delegate.invalidate();
+    }
+    try {
+      final boolean result = delegate.invalidate();
+      span.setData(SpanDataConvention.CACHE_WRITE, result);
+      span.setStatus(SpanStatus.OK);
+      return result;
+    } catch (Throwable e) {
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.setThrowable(e);
+      throw e;
+    } finally {
+      span.finish();
+    }
+  }
+
+  private @Nullable ISpan startSpan(
+      final @Nullable Object key, final @NotNull String operationName) {
+    if (!scopes.getOptions().isEnableCacheTracing()) {
+      return null;
+    }
+
+    final ISpan activeSpan = scopes.getSpan();
+    if (activeSpan == null || activeSpan.isNoOp()) {
+      return null;
+    }
+
+    final SpanOptions spanOptions = new SpanOptions();
+    spanOptions.setOrigin(TRACE_ORIGIN);
+    final String keyString = key != null ? String.valueOf(key) : null;
+    final ISpan span = activeSpan.startChild("cache." + operationName, keyString, spanOptions);
+    if (span.isNoOp()) {
+      return null;
+    }
+    if (keyString != null) {
+      span.setData(SpanDataConvention.CACHE_KEY, Collections.singletonList(keyString));
+    }
+    span.setData(SpanDataConvention.CACHE_OPERATION, operationName);
+    return span;
+  }
+}
diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheBeanPostProcessorTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheBeanPostProcessorTest.kt
new file mode 100644
index 00000000000..4392d6820e5
--- /dev/null
+++ b/sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheBeanPostProcessorTest.kt
@@ -0,0 +1,44 @@
+package io.sentry.spring.cache
+
+import io.sentry.IScopes
+import kotlin.test.Test
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.springframework.cache.CacheManager
+
+class SentryCacheBeanPostProcessorTest {
+
+  private val scopes: IScopes = mock()
+
+  @Test
+  fun `wraps CacheManager beans in SentryCacheManagerWrapper`() {
+    val cacheManager = mock<CacheManager>()
+    val processor = SentryCacheBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(cacheManager, "cacheManager")
+
+    assertTrue(result is SentryCacheManagerWrapper)
+  }
+
+  @Test
+  fun `does not double-wrap SentryCacheManagerWrapper`() {
+    val delegate = mock<CacheManager>()
+    val alreadyWrapped = SentryCacheManagerWrapper(delegate, scopes)
+    val processor = SentryCacheBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(alreadyWrapped, "cacheManager")
+
+    assertSame(alreadyWrapped, result)
+  }
+
+  @Test
+  fun `does not wrap non-CacheManager beans`() {
+    val someBean = "not a cache manager"
+    val processor = SentryCacheBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(someBean, "someBean")
+
+    assertSame(someBean, result)
+  }
+}
diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheManagerWrapperTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheManagerWrapperTest.kt
new file mode 100644
index 00000000000..e3d45038732
--- /dev/null
+++ b/sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheManagerWrapperTest.kt
@@ -0,0 +1,61 @@
+package io.sentry.spring.cache
+
+import io.sentry.IScopes
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+import org.springframework.cache.Cache
+import org.springframework.cache.CacheManager
+
+class SentryCacheManagerWrapperTest {
+
+  private val scopes: IScopes = mock()
+  private val delegate: CacheManager = mock()
+
+  @Test
+  fun `getCache wraps returned cache in SentryCacheWrapper`() {
+    val cache = mock<Cache>()
+    whenever(delegate.getCache("test")).thenReturn(cache)
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.getCache("test")
+
+    assertTrue(result is SentryCacheWrapper)
+  }
+
+  @Test
+  fun `getCache returns null when delegate returns null`() {
+    whenever(delegate.getCache("missing")).thenReturn(null)
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.getCache("missing")
+
+    assertNull(result)
+  }
+
+  @Test
+  fun `getCache does not double-wrap SentryCacheWrapper`() {
+    val innerCache = mock<Cache>()
+    val alreadyWrapped = SentryCacheWrapper(innerCache, scopes)
+    whenever(delegate.getCache("test")).thenReturn(alreadyWrapped)
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.getCache("test")
+
+    assertSame(alreadyWrapped, result)
+  }
+
+  @Test
+  fun `getCacheNames delegates to underlying cache manager`() {
+    whenever(delegate.cacheNames).thenReturn(listOf("cache1", "cache2"))
+
+    val wrapper = SentryCacheManagerWrapper(delegate, scopes)
+    val result = wrapper.cacheNames
+
+    assertEquals(listOf("cache1", "cache2"), result)
+  }
+}
diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheWrapperTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheWrapperTest.kt
new file mode 100644
index 00000000000..ab21ef77b4f
--- /dev/null
+++ b/sentry-spring/src/test/kotlin/io/sentry/spring/cache/SentryCacheWrapperTest.kt
@@ -0,0 +1,354 @@
+package io.sentry.spring.cache
+
+import io.sentry.IScopes
+import io.sentry.SentryOptions
+import io.sentry.SentryTracer
+import io.sentry.SpanDataConvention
+import io.sentry.SpanStatus
+import io.sentry.TransactionContext
+import java.util.concurrent.Callable
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.springframework.cache.Cache
+
+class SentryCacheWrapperTest {
+
+  private lateinit var scopes: IScopes
+  private lateinit var delegate: Cache
+  private lateinit var options: SentryOptions
+
+  @BeforeTest
+  fun setup() {
+    scopes = mock()
+    delegate = mock()
+    options = SentryOptions().apply { isEnableCacheTracing = true }
+    whenever(scopes.options).thenReturn(options)
+    whenever(delegate.name).thenReturn("testCache")
+  }
+
+  private fun createTransaction(): SentryTracer {
+    val tx = SentryTracer(TransactionContext("tx", "op"), scopes)
+    whenever(scopes.span).thenReturn(tx)
+    return tx
+  }
+
+  // -- get(Object key) --
+
+  @Test
+  fun `get with ValueWrapper creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val valueWrapper = mock<Cache.ValueWrapper>()
+    whenever(delegate.get("myKey")).thenReturn(valueWrapper)
+
+    val result = wrapper.get("myKey")
+
+    assertEquals(valueWrapper, result)
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.get", span.operation)
+    assertEquals("myKey", span.description)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_HIT))
+    assertNull(span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("auto.cache.spring", span.spanContext.origin)
+    assertEquals("get", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  @Test
+  fun `get with ValueWrapper creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    val result = wrapper.get("myKey")
+
+    assertNull(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- get(Object key, Class<T>) --
+
+  @Test
+  fun `get with type creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey", String::class.java)).thenReturn("value")
+
+    val result = wrapper.get("myKey", String::class.java)
+
+    assertEquals("value", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  @Test
+  fun `get with type creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey", String::class.java)).thenReturn(null)
+
+    val result = wrapper.get("myKey", String::class.java)
+
+    assertNull(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  @Test
+  fun `get with type sets error status and throwable on exception`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("cache error")
+    whenever(delegate.get("myKey", String::class.java)).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { wrapper.get("myKey", String::class.java) }
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+  }
+
+  // -- get(Object key, Callable<T>) --
+
+  @Test
+  fun `get with callable creates span with cache hit true on hit`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache hit: delegate returns value without invoking the loader
+    whenever(delegate.get(eq("myKey"), any<Callable<String>>())).thenReturn("cached")
+
+    val result = wrapper.get("myKey", Callable { "loaded" })
+
+    assertEquals("cached", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  @Test
+  fun `get with callable creates span with cache hit false on miss`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    // Simulate cache miss: delegate invokes the loader callable
+    whenever(delegate.get(eq("myKey"), any<Callable<String>>())).thenAnswer { invocation ->
+      val loader = invocation.getArgument<Callable<String>>(1)
+      loader.call()
+    }
+
+    val result = wrapper.get("myKey", Callable { "loaded" })
+
+    assertEquals("loaded", result)
+    assertEquals(1, tx.spans.size)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_HIT))
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- put --
+
+  @Test
+  fun `put creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    wrapper.put("myKey", "myValue")
+
+    verify(delegate).put("myKey", "myValue")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.put", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("put", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- putIfAbsent --
+
+  @Test
+  fun `putIfAbsent creates cache put span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.putIfAbsent("myKey", "myValue")).thenReturn(null)
+
+    val result = wrapper.putIfAbsent("myKey", "myValue")
+
+    assertNull(result)
+    verify(delegate).putIfAbsent("myKey", "myValue")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.putIfAbsent", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("putIfAbsent", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- evict --
+
+  @Test
+  fun `evict creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    wrapper.evict("myKey")
+
+    verify(delegate).evict("myKey")
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.evict", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("evict", span.getData(SpanDataConvention.CACHE_OPERATION))
+    assertEquals(listOf("myKey"), span.getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- evictIfPresent --
+
+  @Test
+  fun `evictIfPresent creates cache remove span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.evictIfPresent("myKey")).thenReturn(true)
+
+    val result = wrapper.evictIfPresent("myKey")
+
+    assertTrue(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.evictIfPresent", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("evictIfPresent", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+    assertEquals(listOf("myKey"), tx.spans.first().getData(SpanDataConvention.CACHE_KEY))
+  }
+
+  // -- clear --
+
+  @Test
+  fun `clear creates cache flush span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    wrapper.clear()
+
+    verify(delegate).clear()
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("cache.clear", span.operation)
+    assertEquals(SpanStatus.OK, span.status)
+    assertEquals(true, span.getData(SpanDataConvention.CACHE_WRITE))
+    assertNull(span.getData(SpanDataConvention.CACHE_KEY))
+    assertEquals("clear", span.getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- invalidate --
+
+  @Test
+  fun `invalidate creates cache flush span`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.invalidate()).thenReturn(true)
+
+    val result = wrapper.invalidate()
+
+    assertTrue(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.invalidate", tx.spans.first().operation)
+    assertEquals(true, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("invalidate", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  @Test
+  fun `invalidate sets cache write false when cache had no mappings`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.invalidate()).thenReturn(false)
+
+    val result = wrapper.invalidate()
+
+    assertFalse(result)
+    assertEquals(1, tx.spans.size)
+    assertEquals("cache.invalidate", tx.spans.first().operation)
+    assertEquals(false, tx.spans.first().getData(SpanDataConvention.CACHE_WRITE))
+    assertEquals("invalidate", tx.spans.first().getData(SpanDataConvention.CACHE_OPERATION))
+  }
+
+  // -- no span when no active transaction --
+
+  @Test
+  fun `does not create span when there is no active transaction`() {
+    whenever(scopes.span).thenReturn(null)
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    wrapper.get("myKey")
+
+    verify(delegate).get("myKey")
+  }
+
+  // -- no span when option is disabled --
+
+  @Test
+  fun `does not create span when enableCacheTracing is false`() {
+    options.isEnableCacheTracing = false
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    whenever(delegate.get("myKey")).thenReturn(null)
+
+    wrapper.get("myKey")
+
+    verify(delegate).get("myKey")
+    assertEquals(0, tx.spans.size)
+  }
+
+  // -- error handling --
+
+  @Test
+  fun `sets error status and throwable on exception`() {
+    val tx = createTransaction()
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    val exception = RuntimeException("cache error")
+    whenever(delegate.get("myKey")).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { wrapper.get("myKey") }
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+  }
+
+  // -- delegation --
+
+  @Test
+  fun `getName delegates to underlying cache`() {
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+    assertEquals("testCache", wrapper.name)
+  }
+
+  @Test
+  fun `getNativeCache delegates to underlying cache`() {
+    val nativeCache = Object()
+    whenever(delegate.nativeCache).thenReturn(nativeCache)
+    val wrapper = SentryCacheWrapper(delegate, scopes)
+
+    assertEquals(nativeCache, wrapper.nativeCache)
+  }
+}
diff --git a/sentry-system-test-support/api/sentry-system-test-support.api b/sentry-system-test-support/api/sentry-system-test-support.api
index 51ef7da55d9..83a9f288d0c 100644
--- a/sentry-system-test-support/api/sentry-system-test-support.api
+++ b/sentry-system-test-support/api/sentry-system-test-support.api
@@ -548,7 +548,9 @@ public final class io/sentry/systemtest/util/RestTestClient : io/sentry/systemte
 	public static synthetic fun createPerson$default (Lio/sentry/systemtest/util/RestTestClient;Lio/sentry/systemtest/Person;Ljava/util/Map;ILjava/lang/Object;)Lio/sentry/systemtest/Person;
 	public final fun createPersonDistributedTracing (Lio/sentry/systemtest/Person;Ljava/util/Map;)Lio/sentry/systemtest/Person;
 	public static synthetic fun createPersonDistributedTracing$default (Lio/sentry/systemtest/util/RestTestClient;Lio/sentry/systemtest/Person;Ljava/util/Map;ILjava/lang/Object;)Lio/sentry/systemtest/Person;
+	public final fun deleteCachedTodo (J)V
 	public final fun errorWithFeatureFlag (Ljava/lang/String;)Ljava/lang/String;
+	public final fun getCachedTodo (J)Lio/sentry/systemtest/Todo;
 	public final fun getCountMetric ()Ljava/lang/String;
 	public final fun getDistributionMetric (J)Ljava/lang/String;
 	public final fun getGaugeMetric (J)Ljava/lang/String;
@@ -558,6 +560,7 @@ public final class io/sentry/systemtest/util/RestTestClient : io/sentry/systemte
 	public final fun getTodo (J)Lio/sentry/systemtest/Todo;
 	public final fun getTodoRestClient (J)Lio/sentry/systemtest/Todo;
 	public final fun getTodoWebclient (J)Lio/sentry/systemtest/Todo;
+	public final fun saveCachedTodo (Lio/sentry/systemtest/Todo;)Lio/sentry/systemtest/Todo;
 }
 
 public final class io/sentry/systemtest/util/SentryMockServerClient : io/sentry/systemtest/util/LoggingInsecureRestClient {
diff --git a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/RestTestClient.kt b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/RestTestClient.kt
index bdaa2333f21..da552ff93bc 100644
--- a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/RestTestClient.kt
+++ b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/RestTestClient.kt
@@ -50,6 +50,24 @@ class RestTestClient(private val backendBaseUrl: String) : LoggingInsecureRestCl
     return callTyped(request, true)
   }
 
+  fun getCachedTodo(id: Long): Todo? {
+    val request = Request.Builder().url("$backendBaseUrl/cache/$id")
+
+    return callTyped(request, true)
+  }
+
+  fun saveCachedTodo(todo: Todo): Todo? {
+    val request = Request.Builder().url("$backendBaseUrl/cache/").post(toRequestBody(todo))
+
+    return callTyped(request, true)
+  }
+
+  fun deleteCachedTodo(id: Long) {
+    val request = Request.Builder().url("$backendBaseUrl/cache/$id").delete()
+
+    call(request, true)
+  }
+
   fun checkFeatureFlag(flagKey: String): FeatureFlagResponse? {
     val request = Request.Builder().url("$backendBaseUrl/feature-flag/check/$flagKey")
 
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 1d8ff4d3e0d..c748df38369 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -520,6 +520,7 @@ public final class io/sentry/ExternalOptions {
 	public fun getTracesSampleRate ()Ljava/lang/Double;
 	public fun isCaptureOpenTelemetryEvents ()Ljava/lang/Boolean;
 	public fun isEnableBackpressureHandling ()Ljava/lang/Boolean;
+	public fun isEnableCacheTracing ()Ljava/lang/Boolean;
 	public fun isEnableDatabaseTransactionTracing ()Ljava/lang/Boolean;
 	public fun isEnableLogs ()Ljava/lang/Boolean;
 	public fun isEnableMetrics ()Ljava/lang/Boolean;
@@ -536,6 +537,7 @@ public final class io/sentry/ExternalOptions {
 	public fun setDist (Ljava/lang/String;)V
 	public fun setDsn (Ljava/lang/String;)V
 	public fun setEnableBackpressureHandling (Ljava/lang/Boolean;)V
+	public fun setEnableCacheTracing (Ljava/lang/Boolean;)V
 	public fun setEnableDatabaseTransactionTracing (Ljava/lang/Boolean;)V
 	public fun setEnableDeduplication (Ljava/lang/Boolean;)V
 	public fun setEnableLogs (Ljava/lang/Boolean;)V
@@ -3667,6 +3669,7 @@ public class io/sentry/SentryOptions {
 	public fun isEnableAppStartProfiling ()Z
 	public fun isEnableAutoSessionTracking ()Z
 	public fun isEnableBackpressureHandling ()Z
+	public fun isEnableCacheTracing ()Z
 	public fun isEnableDatabaseTransactionTracing ()Z
 	public fun isEnableDeduplication ()Z
 	public fun isEnableEventSizeLimiting ()Z
@@ -3725,6 +3728,7 @@ public class io/sentry/SentryOptions {
 	public fun setEnableAppStartProfiling (Z)V
 	public fun setEnableAutoSessionTracking (Z)V
 	public fun setEnableBackpressureHandling (Z)V
+	public fun setEnableCacheTracing (Z)V
 	public fun setEnableDatabaseTransactionTracing (Z)V
 	public fun setEnableDeduplication (Z)V
 	public fun setEnableEventSizeLimiting (Z)V
@@ -4352,6 +4356,10 @@ public final class io/sentry/SpanContext$JsonKeys {
 
 public abstract interface class io/sentry/SpanDataConvention {
 	public static final field BLOCKED_MAIN_THREAD_KEY Ljava/lang/String;
+	public static final field CACHE_HIT Ljava/lang/String;
+	public static final field CACHE_KEY Ljava/lang/String;
+	public static final field CACHE_OPERATION Ljava/lang/String;
+	public static final field CACHE_WRITE Ljava/lang/String;
 	public static final field CALL_STACK_KEY Ljava/lang/String;
 	public static final field CONTRIBUTES_TTFD Ljava/lang/String;
 	public static final field CONTRIBUTES_TTID Ljava/lang/String;
diff --git a/sentry/src/main/java/io/sentry/ExternalOptions.java b/sentry/src/main/java/io/sentry/ExternalOptions.java
index 8f16bcede01..dade1f140c8 100644
--- a/sentry/src/main/java/io/sentry/ExternalOptions.java
+++ b/sentry/src/main/java/io/sentry/ExternalOptions.java
@@ -57,6 +57,7 @@ public final class ExternalOptions {
   private @Nullable Boolean sendDefaultPii;
   private @Nullable Boolean enableBackpressureHandling;
   private @Nullable Boolean enableDatabaseTransactionTracing;
+  private @Nullable Boolean enableCacheTracing;
   private @Nullable Boolean globalHubMode;
   private @Nullable Boolean forceInit;
   private @Nullable Boolean captureOpenTelemetryEvents;
@@ -162,6 +163,8 @@ public final class ExternalOptions {
     options.setEnableDatabaseTransactionTracing(
         propertiesProvider.getBooleanProperty("enable-database-transaction-tracing"));
 
+    options.setEnableCacheTracing(propertiesProvider.getBooleanProperty("enable-cache-tracing"));
+
     options.setGlobalHubMode(propertiesProvider.getBooleanProperty("global-hub-mode"));
 
     options.setCaptureOpenTelemetryEvents(
@@ -523,6 +526,14 @@ public void setEnableDatabaseTransactionTracing(
     return enableDatabaseTransactionTracing;
   }
 
+  public void setEnableCacheTracing(final @Nullable Boolean enableCacheTracing) {
+    this.enableCacheTracing = enableCacheTracing;
+  }
+
+  public @Nullable Boolean isEnableCacheTracing() {
+    return enableCacheTracing;
+  }
+
   public void setGlobalHubMode(final @Nullable Boolean globalHubMode) {
     this.globalHubMode = globalHubMode;
   }
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 862bd708aa4..9df125b4d11 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -490,6 +490,9 @@ public class SentryOptions {
   /** Whether database transaction spans (BEGIN, COMMIT, ROLLBACK) should be traced. */
   private boolean enableDatabaseTransactionTracing = false;
 
+  /** Whether cache operations (get, put, remove, flush) should be traced. */
+  private boolean enableCacheTracing = false;
+
   /** Date provider to retrieve the current date from. */
   @ApiStatus.Internal
   private final @NotNull LazyEvaluator<SentryDateProvider> dateProvider =
@@ -2632,6 +2635,24 @@ public void setEnableDatabaseTransactionTracing(boolean enableDatabaseTransactio
     this.enableDatabaseTransactionTracing = enableDatabaseTransactionTracing;
   }
 
+  /**
+   * Whether cache operations (get, put, remove, flush) should be traced.
+   *
+   * @return true if cache operations should be traced
+   */
+  public boolean isEnableCacheTracing() {
+    return enableCacheTracing;
+  }
+
+  /**
+   * Whether cache operations (get, put, remove, flush) should be traced.
+   *
+   * @param enableCacheTracing true if cache operations should be traced
+   */
+  public void setEnableCacheTracing(boolean enableCacheTracing) {
+    this.enableCacheTracing = enableCacheTracing;
+  }
+
   /**
    * Whether Sentry is enabled.
    *
@@ -3470,6 +3491,9 @@ public void merge(final @NotNull ExternalOptions options) {
     if (options.isEnableDatabaseTransactionTracing() != null) {
       setEnableDatabaseTransactionTracing(options.isEnableDatabaseTransactionTracing());
     }
+    if (options.isEnableCacheTracing() != null) {
+      setEnableCacheTracing(options.isEnableCacheTracing());
+    }
     if (options.getMaxRequestBodySize() != null) {
       setMaxRequestBodySize(options.getMaxRequestBodySize());
     }
diff --git a/sentry/src/main/java/io/sentry/SpanDataConvention.java b/sentry/src/main/java/io/sentry/SpanDataConvention.java
index c4329f6dcad..647c0dacddf 100644
--- a/sentry/src/main/java/io/sentry/SpanDataConvention.java
+++ b/sentry/src/main/java/io/sentry/SpanDataConvention.java
@@ -26,4 +26,8 @@ public interface SpanDataConvention {
   String HTTP_START_TIMESTAMP = "http.start_timestamp";
   String HTTP_END_TIMESTAMP = "http.end_timestamp";
   String PROFILER_ID = "profiler_id";
+  String CACHE_HIT = "cache.hit";
+  String CACHE_KEY = "cache.key";
+  String CACHE_OPERATION = "cache.operation";
+  String CACHE_WRITE = "cache.write";
 }
diff --git a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
index 9612a052624..298eff34ba0 100644
--- a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
@@ -331,6 +331,20 @@ class ExternalOptionsTest {
     }
   }
 
+  @Test
+  fun `creates options with enableCacheTracing set to true`() {
+    withPropertiesFile("enable-cache-tracing=true") { options ->
+      assertTrue(options.isEnableCacheTracing == true)
+    }
+  }
+
+  @Test
+  fun `creates options with enableCacheTracing set to false`() {
+    withPropertiesFile("enable-cache-tracing=false") { options ->
+      assertTrue(options.isEnableCacheTracing == false)
+    }
+  }
+
   @Test
   fun `creates options with cron defaults`() {
     withPropertiesFile(
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index 1fd8d9cc81f..1b9ce5eace3 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -400,6 +400,7 @@ class SentryOptionsTest {
     externalOptions.ignoredErrors = listOf("Some error", "Another .*")
     externalOptions.isEnableBackpressureHandling = false
     externalOptions.isEnableDatabaseTransactionTracing = true
+    externalOptions.isEnableCacheTracing = true
     externalOptions.maxRequestBodySize = SentryOptions.RequestSize.MEDIUM
     externalOptions.isSendDefaultPii = true
     externalOptions.isForceInit = true
@@ -465,6 +466,7 @@ class SentryOptionsTest {
     )
     assertFalse(options.isEnableBackpressureHandling)
     assertTrue(options.isEnableDatabaseTransactionTracing)
+    assertTrue(options.isEnableCacheTracing)
     assertTrue(options.isForceInit)
     assertNotNull(options.cron)
     assertEquals(10L, options.cron?.defaultCheckinMargin)
@@ -701,6 +703,11 @@ class SentryOptionsTest {
     assertFalse(SentryOptions().isEnableDatabaseTransactionTracing)
   }
 
+  @Test
+  fun `when options are initialized, enableCacheTracing is set to false by default`() {
+    assertFalse(SentryOptions().isEnableCacheTracing)
+  }
+
   @Test
   fun `when options are initialized, metrics is enabled by default`() {
     assertTrue(SentryOptions().metrics.isEnabled)
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 0e9987b4ae4..8d431d5fbdf 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -66,6 +66,7 @@ include(
     "sentry-opentelemetry:sentry-opentelemetry-agentless-spring",
     "sentry-opentelemetry:sentry-opentelemetry-otlp",
     "sentry-opentelemetry:sentry-opentelemetry-otlp-spring",
+    "sentry-jcache",
     "sentry-quartz",
     "sentry-okhttp",
     "sentry-openfeature",
diff --git a/test/system-test-runner.py b/test/system-test-runner.py
index 55a1136fbe0..70489c580a5 100644
--- a/test/system-test-runner.py
+++ b/test/system-test-runner.py
@@ -61,7 +61,8 @@
     "OTEL_TRACES_EXPORTER": "none",
     "OTEL_METRICS_EXPORTER": "none",
     "OTEL_LOGS_EXPORTER": "none",
-    "SENTRY_LOGS_ENABLED": "true"
+    "SENTRY_LOGS_ENABLED": "true",
+    "SENTRY_ENABLE_CACHE_TRACING": "true"
 }
 
 class ServerType(Enum):

From 72ab40d6fcb24c6a19311bf4028ba1ad28ec345e Mon Sep 17 00:00:00 2001
From: adinauer <2542832+adinauer@users.noreply.github.com>
Date: Wed, 25 Mar 2026 10:41:08 +0000
Subject: [PATCH 072/391] release: 8.37.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fabd81c5746..fde4587e625 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.37.0
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index c9900e412b3..cdae82047e2 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.9.0
 
 # Release information
-versionName=8.36.0
+versionName=8.37.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 8c1fb225bde207e1c97fec88db1d3deb93fc45ea Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 25 Mar 2026 13:07:07 +0100
Subject: [PATCH 073/391] chore(changelog): Update dependencies section with
 Native SDK version bump (#5217)

* chore(changelog): Update dependencies section with Native SDK version bump

* Refine SentryAndroid replay capture logic

Updated SentryAndroid initialization code to capture replay only for crashes.

* Change example usage from Java to Kotlin

Updated example usage in CHANGELOG to use Kotlin.
---
 CHANGELOG.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fde4587e625..ff1597652b1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,19 +19,21 @@
   - Allows filtering which errors trigger replay capture before the `onErrorSampleRate` is checked
   - Returning `false` skips replay capture entirely for that error; returning `true` proceeds with the normal sample rate check
   - Example usage:
-    ```java
+    ```kotlin
     SentryAndroid.init(context) { options ->
         options.sessionReplay.beforeErrorSampling =
             SentryReplayOptions.BeforeErrorSamplingCallback { event, hint ->
-                // Skip replay for handled exceptions
-                val hasUnhandled = event.exceptions?.any { it.mechanism?.isHandled == false } == true
-                hasUnhandled
+                // Only capture replay for crashes (excluding e.g. handled exceptions)
+                event.isCrashed
             }
     }
     ```
 
 ### Dependencies
 
+- Bump Native SDK from v0.13.2 to v0.13.3 ([#5215](https://github.com/getsentry/sentry-java/pull/5215))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0133)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.13.2...0.13.3)
 - Bump OpenTelemetry ([#5225](https://github.com/getsentry/sentry-java/pull/5225))
   - `opentelemetry` to `1.60.1` (was `1.57.0`)
   - `opentelemetry-instrumentation` to `2.26.0` (was `2.23.0`)

From a7fc3666eb04bed49f438906ccab126b1e03130e Mon Sep 17 00:00:00 2001
From: joshuarli <joshuarli98@gmail.com>
Date: Thu, 26 Mar 2026 02:16:20 -0700
Subject: [PATCH 074/391] chore(github): pin GitHub Actions to full-length
 commit SHAs (#5229)

---
 .github/workflows/agp-matrix.yml                   |  8 ++++----
 .github/workflows/build.yml                        |  8 ++++----
 .github/workflows/changelog-preview.yml            |  2 +-
 .github/workflows/changes-in-high-risk-code.yml    |  4 ++--
 .github/workflows/check-tombstone-proto-schema.yml |  2 +-
 .github/workflows/codeql-analysis.yml              |  4 ++--
 .github/workflows/danger.yml                       |  2 +-
 .github/workflows/enforce-license-compliance.yml   |  6 +++---
 .github/workflows/format-code.yml                  |  4 ++--
 .github/workflows/generate-javadocs.yml            |  4 ++--
 .github/workflows/integration-tests-benchmarks.yml | 10 +++++-----
 .github/workflows/integration-tests-size.yml       |  6 +++---
 .../workflows/integration-tests-ui-critical.yml    | 14 +++++++-------
 .github/workflows/integration-tests-ui.yml         |  4 ++--
 .github/workflows/release-build.yml                |  6 +++---
 .github/workflows/release.yml                      |  2 +-
 .github/workflows/spring-boot-2-matrix.yml         | 10 +++++-----
 .github/workflows/spring-boot-3-matrix.yml         | 10 +++++-----
 .github/workflows/spring-boot-4-matrix.yml         | 10 +++++-----
 .github/workflows/system-tests-backend.yml         |  8 ++++----
 .github/workflows/update-deps.yml                  |  4 ++--
 21 files changed, 64 insertions(+), 64 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index c6bee353d83..750be7ca2e4 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -28,12 +28,12 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -50,7 +50,7 @@ jobs:
           sudo udevadm trigger --name-match=kvm
 
       - name: AVD cache
-        uses: actions/cache@v5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
         id: avd-cache
         with:
           path: |
@@ -94,7 +94,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
         with:
           name: test-results-AGP${{ matrix.agp }}-Integrations${{ matrix.integrations }}
           path: |
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 56e832b8e43..3e5a79f5930 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -19,19 +19,19 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@v5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
@@ -53,7 +53,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
         with:
           name: test-results-build
           path: |
diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index af9087141e7..2b37e202856 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@f4889d04564e47311038ecb6b910fef6b6cf1363 # v2
     secrets: inherit
diff --git a/.github/workflows/changes-in-high-risk-code.yml b/.github/workflows/changes-in-high-risk-code.yml
index 5da9f52cb50..e22fa135412 100644
--- a/.github/workflows/changes-in-high-risk-code.yml
+++ b/.github/workflows/changes-in-high-risk-code.yml
@@ -16,7 +16,7 @@ jobs:
       high_risk_code: ${{ steps.changes.outputs.high_risk_code }}
       high_risk_code_files: ${{ steps.changes.outputs.high_risk_code_files }}
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
       - name: Get changed files
         id: changes
         uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
@@ -34,7 +34,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Comment on PR to notify of changes in high risk files
-        uses: actions/github-script@v8
+        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
         env:
           high_risk_code: ${{ needs.files-changed.outputs.high_risk_code_files }}
         with:
diff --git a/.github/workflows/check-tombstone-proto-schema.yml b/.github/workflows/check-tombstone-proto-schema.yml
index 9234be0c429..f4dd5f2f957 100644
--- a/.github/workflows/check-tombstone-proto-schema.yml
+++ b/.github/workflows/check-tombstone-proto-schema.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
       - name: Check for newer Tombstone proto schema
         run: ./scripts/check-tombstone-proto-schema.sh
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 703c4abe043..06aa7fdcba4 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -20,12 +20,12 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/danger.yml b/.github/workflows/danger.yml
index 7f2045ea980..77fe824701a 100644
--- a/.github/workflows/danger.yml
+++ b/.github/workflows/danger.yml
@@ -8,4 +8,4 @@ jobs:
   danger:
     runs-on: ubuntu-latest
     steps:
-      - uses: getsentry/github-workflows/danger@v3
+      - uses: getsentry/github-workflows/danger@26f565c05d0dd49f703d238706b775883037d76b # v3
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index ca27a0b201a..1d1493bb7bf 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -14,20 +14,20 @@ jobs:
         uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
 
       - name: Set up Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
       # TODO: remove this when upstream is fixed
       - name: Disable Gradle configuration cache (see https://github.com/fossas/fossa-cli/issues/872)
         run: sed -i 's/^org.gradle.configuration-cache=.*/org.gradle.configuration-cache=false/' gradle.properties
 
       - name: 'Enforce License Compliance'
-        uses: getsentry/action-enforce-license-compliance@main
+        uses: getsentry/action-enforce-license-compliance@48236a773346cb6552a7bda1ee370d2797365d87 # main
         with:
           skip_checkout: 'true'
           fossa_test_timeout_seconds: 3600
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index 197b5d95659..c338400f958 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -8,12 +8,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index 7909b659108..b50d42f7d1d 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -9,12 +9,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout 🛎️
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 24310f9ec81..dec5c8eae51 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -27,12 +27,12 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -77,12 +77,12 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -92,7 +92,7 @@ jobs:
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
-      - uses: actions/cache@v5
+      - uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
         id: app-plain-cache
         with:
           path: sentry-android-integration-tests/test-app-plain/build/outputs/apk/release/test-app-plain-release.apk
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index 7df0d8bb65d..615d447cbf2 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -20,17 +20,17 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
       - name: Setup Java Version
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: "temurin"
           java-version: "17"
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@v5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 04e7f834f1f..446228943b5 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -27,10 +27,10 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
       - name: Set up Java 17
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -44,7 +44,7 @@ jobs:
         run: make assembleUiTestCriticalRelease
 
       - name: Upload APK artifact
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
         with:
           name: ${{env.APK_ARTIFACT_NAME}}
           path: "${{env.BASE_PATH}}/${{env.BUILD_PATH}}/${{env.APK_NAME}}"
@@ -81,7 +81,7 @@ jobs:
             arch: x86_64
     steps:
       - name: Checkout code
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
       - name: Enable KVM
         run: |
@@ -90,7 +90,7 @@ jobs:
           sudo udevadm trigger --name-match=kvm
 
       - name: AVD cache
-        uses: actions/cache@v5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
         id: avd-cache
         with:
           path: |
@@ -114,7 +114,7 @@ jobs:
           script: echo "Generated AVD snapshot for caching."
 
       - name: Download APK artifact
-        uses: actions/download-artifact@v8
+        uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8
         with:
           name: ${{env.APK_ARTIFACT_NAME}}
 
@@ -141,7 +141,7 @@ jobs:
 
       - name: Upload Maestro test results
         if: ${{ always() }}
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
         with:
           name: maestro-logs-${{ matrix.api-level }}-${{ matrix.arch }}-${{ matrix.target }}
           path: "${{env.BASE_PATH}}/maestro-logs"
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 41f3829993d..bbaaa88f53a 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -22,12 +22,12 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 7e7774365b9..62d2d5caa43 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -15,12 +15,12 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -32,7 +32,7 @@ jobs:
         run: make publish
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
         with:
           name: ${{ github.sha }}
           if-no-files-found: error
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index f7c530df16a..cdf7c141026 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -27,7 +27,7 @@ jobs:
         with:
           app-id: ${{ vars.SENTRY_RELEASE_BOT_CLIENT_ID }}
           private-key: ${{ secrets.SENTRY_RELEASE_BOT_PRIVATE_KEY }}
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           token: ${{ steps.token.outputs.token }}
           # Needs to be set, otherwise git describe --tags will fail with: No names found, cannot describe anything
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index a6c2d7b48b7..3e57dfd907e 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -28,12 +28,12 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: Set up Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
         with:
           python-version: '3.10.5'
 
@@ -43,14 +43,14 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@v5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
@@ -150,7 +150,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
         with:
           name: test-results-springboot-2-${{ matrix.springboot-version }}
           path: |
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 03232723741..ed8669e60f3 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -28,12 +28,12 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: Set up Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
         with:
           python-version: '3.10.5'
 
@@ -43,14 +43,14 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@v5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
@@ -150,7 +150,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
         with:
           name: test-results-springboot-3-${{ matrix.springboot-version }}
           path: |
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index b436a7f31ed..67c5efe8700 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -28,12 +28,12 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@v6
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
       - name: Set up Python
-        uses: actions/setup-python@v6
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
         with:
           python-version: '3.10.5'
 
@@ -43,14 +43,14 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@v5
+        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
@@ -150,7 +150,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
         with:
           name: test-results-springboot-4-${{ matrix.springboot-version }}
           path: |
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index f57f81aaf84..f225be8faf6 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -94,11 +94,11 @@ jobs:
             agent: "false"
             agent-auto-init: "true"
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
           submodules: 'recursive'
 
-      - uses: actions/setup-python@v6
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
         with:
           python-version: '3.10.5'
 
@@ -108,7 +108,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@v5
+        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -153,7 +153,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
         with:
           name: test-results-${{ matrix.sample }}-${{ matrix.agent }}-${{ matrix.agent-auto-init }}-system-test
           path: |
diff --git a/.github/workflows/update-deps.yml b/.github/workflows/update-deps.yml
index e4e2d5433b7..a8bb5f655a1 100644
--- a/.github/workflows/update-deps.yml
+++ b/.github/workflows/update-deps.yml
@@ -18,7 +18,7 @@ jobs:
   native:
     runs-on: ubuntu-latest
     steps:
-      - uses: getsentry/github-workflows/updater@v3
+      - uses: getsentry/github-workflows/updater@26f565c05d0dd49f703d238706b775883037d76b # v3
         with:
           path: scripts/update-sentry-native-ndk.sh
           name: Native SDK
@@ -27,7 +27,7 @@ jobs:
   gradle-wrapper:
     runs-on: ubuntu-latest
     steps:
-      - uses: getsentry/github-workflows/updater@v3
+      - uses: getsentry/github-workflows/updater@26f565c05d0dd49f703d238706b775883037d76b # v3
         with:
           path: scripts/update-gradle.sh
           name: Gradle

From f2c2e7d827d945de83595d7fc62579e8b0dc085e Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Thu, 26 Mar 2026 11:16:02 +0100
Subject: [PATCH 075/391] fix(otel): Avoid deadlock in
 SentryContextStorage.root() with virtual threads (#5234)

* fix(otel): Avoid deadlock in SentryContextStorage.root() with virtual threads

SentryContextStorage.root() called SentryContextWrapper.wrap() which
triggers scope.clone() and acquires locks. Under virtual threads,
ReentrantLock.unlock() can re-enter root() via OpenTelemetry executor
instrumentation on ForkJoinPool.execute(), causing a deadlock.

Return the default OTel root context without wrapping. Scopes are
resolved later via attach() or Sentry.getCurrentScopes().

Fixes GH-5226
Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                                | 6 ++++++
 .../java/io/sentry/opentelemetry/SentryContextStorage.java  | 5 ++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ff1597652b1..8ea323e0ad5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Fix deadlock in `SentryContextStorage.root()` with virtual threads and OpenTelemetry agent ([#5234](https://github.com/getsentry/sentry-java/pull/5234))
+
 ## 8.37.0
 
 ### Fixes
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/main/java/io/sentry/opentelemetry/SentryContextStorage.java b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/main/java/io/sentry/opentelemetry/SentryContextStorage.java
index 5a916a9ecab..c97e40ea62d 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/main/java/io/sentry/opentelemetry/SentryContextStorage.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/main/java/io/sentry/opentelemetry/SentryContextStorage.java
@@ -41,6 +41,9 @@ public Context current() {
 
   @Override
   public Context root() {
-    return SentryContextWrapper.wrap(ContextStorage.super.root());
+    // Don't wrap() here — it triggers scope.clone() which acquires locks. Under virtual
+    // threads, lock.unlock() can re-enter here via OpenTelemetry executor instrumentation, causing
+    // a deadlock.
+    return ContextStorage.super.root();
   }
 }

From f967be65f01220214f9c487c7994ce930b2864c4 Mon Sep 17 00:00:00 2001
From: adinauer <2542832+adinauer@users.noreply.github.com>
Date: Thu, 26 Mar 2026 10:16:42 +0000
Subject: [PATCH 076/391] release: 8.37.1

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8ea323e0ad5..6f68583a5fe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.37.1
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index cdae82047e2..3ce5df53b45 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.9.0
 
 # Release information
-versionName=8.37.0
+versionName=8.37.1
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 1d4a07a7408869f170ad014e303d8fb6e30cdda1 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Thu, 26 Mar 2026 13:11:19 +0100
Subject: [PATCH 077/391] chore: Add error monitoring solution question to bug
 report templates (#5185)

* chore(android): Add error monitoring solution question to bug report template

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore(java): Add error monitoring solution question to Java bug report template

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore: Address PR feedback on issue templates

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: Typo your -> you're in issue templates

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Address PR feedback

* Omit reserved word

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/ISSUE_TEMPLATE/bug_report_android.yml | 16 ++++++++++++++++
 .github/ISSUE_TEMPLATE/bug_report_java.yml    | 19 +++++++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/.github/ISSUE_TEMPLATE/bug_report_android.yml b/.github/ISSUE_TEMPLATE/bug_report_android.yml
index e83e485450d..5dff43579c6 100644
--- a/.github/ISSUE_TEMPLATE/bug_report_android.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report_android.yml
@@ -55,6 +55,22 @@ body:
     validations:
       required: true
 
+  - type: dropdown
+    id: other_error_monitoring_solution
+    attributes:
+      description: Are you using any other error monitoring solution alongside Sentry?
+      label: Other Error Monitoring Solution
+      options:
+        - "No"
+        - "Bugsnag"
+        - "Datadog"
+        - "Firebase Crashlytics"
+        - "Instabug/Luciq"
+        - "NewRelic"
+        - "Other (please mention in issue description)"
+    validations:
+      required: true
+
   - type: input
     id: version
     attributes:
diff --git a/.github/ISSUE_TEMPLATE/bug_report_java.yml b/.github/ISSUE_TEMPLATE/bug_report_java.yml
index 3f2df40888b..8355d75a43b 100644
--- a/.github/ISSUE_TEMPLATE/bug_report_java.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report_java.yml
@@ -53,6 +53,25 @@ body:
     validations:
       required: true
 
+  - type: dropdown
+    id: other_error_monitoring
+    attributes:
+      description: Are you using any other error monitoring solution alongside Sentry?
+      label: Other Error Monitoring Solution
+      options:
+        - "Yes"
+        - "No"
+    validations:
+      required: true
+
+  - type: input
+    id: other_error_monitoring_name
+    attributes:
+      label: Other Error Monitoring Solution Name
+      description: If you're using another error monitoring solution side-by-side, please enter the name of the other solution.
+    validations:
+      required: false
+
   - type: input
     id: version
     attributes:

From 11f416162b4e623ccccedebba41fc2a08fcf3374 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Fri, 27 Mar 2026 13:30:15 +0100
Subject: [PATCH 078/391] ci: Bump Spring Boot versions in CI matrix (#5235)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Update Spring Boot 3.x patch versions:
- 3.2.10 → 3.2.12
- 3.3.5 → 3.3.13
- 3.4.5 → 3.4.13
- 3.5.6 → 3.5.13

Add Spring Boot 4.0.5 to 4.x matrix.

Co-authored-by: Claude <noreply@anthropic.com>
---
 .github/workflows/spring-boot-3-matrix.yml | 2 +-
 .github/workflows/spring-boot-4-matrix.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index ed8669e60f3..4abb488387a 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -19,7 +19,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        springboot-version: [ '3.0.0', '3.2.10', '3.3.5', '3.4.5', '3.5.6' ]
+        springboot-version: [ '3.0.0', '3.2.12', '3.3.13', '3.4.13', '3.5.13' ]
 
     name: Spring Boot ${{ matrix.springboot-version }}
     env:
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 67c5efe8700..6466abb58ae 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -19,7 +19,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        springboot-version: [ '4.0.0' ]
+        springboot-version: [ '4.0.0', '4.0.5' ]
 
     name: Spring Boot ${{ matrix.springboot-version }}
     env:

From 6285fcce78720c0dab4c9df7d989c950b48b297c Mon Sep 17 00:00:00 2001
From: Stephanie Anderson <stephanie.anderson@sentry.io>
Date: Fri, 27 Mar 2026 15:50:26 +0100
Subject: [PATCH 079/391] chore: Add PR validation workflow (#5239)

Automatically validates non-maintainer PRs by checking:
- Issue reference exists in PR body
- Referenced issue has discussion between author and maintainer
- Referenced issue is not assigned to someone else

Also enforces that all PRs start as drafts.

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/workflows/validate-pr.yml | 327 ++++++++++++++++++++++++++++++
 1 file changed, 327 insertions(+)
 create mode 100644 .github/workflows/validate-pr.yml

diff --git a/.github/workflows/validate-pr.yml b/.github/workflows/validate-pr.yml
new file mode 100644
index 00000000000..e826cb338a7
--- /dev/null
+++ b/.github/workflows/validate-pr.yml
@@ -0,0 +1,327 @@
+name: Validate PR
+
+on:
+  pull_request_target:
+    types: [opened, reopened]
+
+jobs:
+  validate-non-maintainer-pr:
+    name: Validate Non-Maintainer PR
+    runs-on: ubuntu-24.04
+    permissions:
+      pull-requests: write
+      contents: write
+    outputs:
+      was-closed: ${{ steps.validate.outputs.was-closed }}
+    steps:
+      - name: Generate GitHub App token
+        id: app-token
+        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859  # v2
+        with:
+          app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
+          private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}
+
+      - name: Validate PR
+        id: validate
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea  # v7.0.1
+        with:
+          github-token: ${{ steps.app-token.outputs.token }}
+          script: |
+            const pullRequest = context.payload.pull_request;
+            const repo = context.repo;
+            const prAuthor = pullRequest.user.login;
+            const contributingUrl = `https://github.com/${repo.owner}/${repo.repo}/blob/${context.payload.repository.default_branch}/CONTRIBUTING.md`;
+
+            // --- Helper: check if a user has admin or maintain permission on a repo (cached) ---
+            const maintainerCache = new Map();
+            async function isMaintainer(owner, repoName, username) {
+              const key = `${owner}/${repoName}:${username}`;
+              if (maintainerCache.has(key)) return maintainerCache.get(key);
+              let result = false;
+              try {
+                const { data } = await github.rest.repos.getCollaboratorPermissionLevel({
+                  owner,
+                  repo: repoName,
+                  username,
+                });
+                // permission field uses legacy values (admin/write/read/none) where
+                // maintain maps to write. Use role_name for the actual role.
+                result = ['admin', 'maintain'].includes(data.role_name);
+              } catch {
+                // noop — result stays false
+              }
+              maintainerCache.set(key, result);
+              return result;
+            }
+
+            // --- Step 1: Check if PR author is a maintainer (admin or maintain role) ---
+            const authorIsMaintainer = await isMaintainer(repo.owner, repo.repo, prAuthor);
+            if (authorIsMaintainer) {
+              core.info(`PR author ${prAuthor} has admin/maintain access. Skipping.`);
+              return;
+            }
+            core.info(`PR author ${prAuthor} is not a maintainer.`);
+
+            // --- Step 2: Parse issue references from PR body ---
+            const body = pullRequest.body || '';
+
+            // Match all issue reference formats:
+            //   #123, Fixes #123, getsentry/repo#123, Fixes getsentry/repo#123
+            //   https://github.com/getsentry/repo/issues/123
+            const issueRefs = [];
+            const seen = new Set();
+
+            // Pattern 1: Full GitHub URLs
+            const urlPattern = /https?:\/\/github\.com\/(getsentry)\/([\w.-]+)\/issues\/(\d+)/gi;
+            for (const match of body.matchAll(urlPattern)) {
+              const key = `${match[1]}/${match[2]}#${match[3]}`;
+              if (!seen.has(key)) {
+                seen.add(key);
+                issueRefs.push({ owner: match[1], repo: match[2], number: parseInt(match[3]) });
+              }
+            }
+
+            // Pattern 2: Cross-repo references (getsentry/repo#123)
+            const crossRepoPattern = /(?:(?:fix|fixes|fixed|close|closes|closed|resolve|resolves|resolved)\s+)?(getsentry)\/([\w.-]+)#(\d+)/gi;
+            for (const match of body.matchAll(crossRepoPattern)) {
+              const key = `${match[1]}/${match[2]}#${match[3]}`;
+              if (!seen.has(key)) {
+                seen.add(key);
+                issueRefs.push({ owner: match[1], repo: match[2], number: parseInt(match[3]) });
+              }
+            }
+
+            // Pattern 3: Same-repo references (#123)
+            // Negative lookbehind to avoid matching cross-repo refs or URLs already captured
+            const sameRepoPattern = /(?:(?:fix|fixes|fixed|close|closes|closed|resolve|resolves|resolved)\s+)?(?<![/\w])#(\d+)/gi;
+            for (const match of body.matchAll(sameRepoPattern)) {
+              const key = `${repo.owner}/${repo.repo}#${match[1]}`;
+              if (!seen.has(key)) {
+                seen.add(key);
+                issueRefs.push({ owner: repo.owner, repo: repo.repo, number: parseInt(match[1]) });
+              }
+            }
+
+            core.info(`Found ${issueRefs.length} issue reference(s): ${[...seen].join(', ')}`);
+
+            // --- Helper: close PR with comment and labels ---
+            async function closePR(message, reasonLabel) {
+              await github.rest.issues.addLabels({
+                ...repo,
+                issue_number: pullRequest.number,
+                labels: ['violating-contribution-guidelines', reasonLabel],
+              });
+
+              await github.rest.issues.createComment({
+                ...repo,
+                issue_number: pullRequest.number,
+                body: message,
+              });
+
+              await github.rest.pulls.update({
+                ...repo,
+                pull_number: pullRequest.number,
+                state: 'closed',
+              });
+
+              core.setOutput('was-closed', 'true');
+            }
+
+            // --- Step 3: No issue references ---
+            if (issueRefs.length === 0) {
+              core.info('No issue references found. Closing PR.');
+              await closePR([
+                'This PR has been automatically closed. All non-maintainer contributions must reference an existing GitHub issue.',
+                '',
+                '**Next steps:**',
+                '1. Find or open an issue describing the problem or feature',
+                '2. Discuss the approach with a maintainer in the issue',
+                '3. Once a maintainer has acknowledged your proposed approach, open a new PR referencing the issue',
+                '',
+                `Please review our [contributing guidelines](${contributingUrl}) for more details.`,
+              ].join('\n'), 'missing-issue-reference');
+              return;
+            }
+
+            // --- Step 4: Validate each referenced issue ---
+            // A PR is valid if ANY referenced issue passes all checks.
+            let hasAssigneeConflict = false;
+            let hasNoDiscussion = false;
+
+            for (const ref of issueRefs) {
+              core.info(`Checking issue ${ref.owner}/${ref.repo}#${ref.number}...`);
+
+              let issue;
+              try {
+                const { data } = await github.rest.issues.get({
+                  owner: ref.owner,
+                  repo: ref.repo,
+                  issue_number: ref.number,
+                });
+                issue = data;
+              } catch (e) {
+                core.warning(`Could not fetch issue ${ref.owner}/${ref.repo}#${ref.number}: ${e.message}`);
+                continue;
+              }
+
+              // Check assignee: if assigned to someone other than PR author, flag it
+              if (issue.assignees && issue.assignees.length > 0) {
+                const assignedToAuthor = issue.assignees.some(a => a.login === prAuthor);
+                if (!assignedToAuthor) {
+                  core.info(`Issue ${ref.owner}/${ref.repo}#${ref.number} is assigned to someone else.`);
+                  hasAssigneeConflict = true;
+                  continue;
+                }
+              }
+
+              // Check discussion: both PR author and a maintainer must have commented
+              const comments = await github.paginate(github.rest.issues.listComments, {
+                owner: ref.owner,
+                repo: ref.repo,
+                issue_number: ref.number,
+                per_page: 100,
+              });
+
+              // Also consider the issue author as a participant (opening the issue is a form of discussion)
+              // Guard against null user (deleted/suspended GitHub accounts)
+              const prAuthorParticipated =
+                issue.user?.login === prAuthor ||
+                comments.some(c => c.user?.login === prAuthor);
+
+              let maintainerParticipated = false;
+              if (prAuthorParticipated) {
+                // Check each commenter (and issue author) for admin/maintain access on the issue's repo
+                const usersToCheck = new Set();
+                if (issue.user?.login) usersToCheck.add(issue.user.login);
+                for (const comment of comments) {
+                  if (comment.user?.login && comment.user.login !== prAuthor) {
+                    usersToCheck.add(comment.user.login);
+                  }
+                }
+
+                for (const user of usersToCheck) {
+                  if (user === prAuthor) continue;
+                  if (await isMaintainer(repo.owner, repo.repo, user)) {
+                    maintainerParticipated = true;
+                    core.info(`Maintainer ${user} participated in ${ref.owner}/${ref.repo}#${ref.number}.`);
+                    break;
+                  }
+                }
+              }
+
+              if (prAuthorParticipated && maintainerParticipated) {
+                core.info(`Issue ${ref.owner}/${ref.repo}#${ref.number} has valid discussion. PR is allowed.`);
+                return;  // PR is valid — at least one issue passes all checks
+              }
+
+              core.info(`Issue ${ref.owner}/${ref.repo}#${ref.number} lacks discussion between author and maintainer.`);
+              hasNoDiscussion = true;
+            }
+
+            // --- Step 5: No valid issue found — close with the most relevant reason ---
+            if (hasAssigneeConflict) {
+              core.info('Closing PR: referenced issue is assigned to someone else.');
+              await closePR([
+                'This PR has been automatically closed. The referenced issue is already assigned to someone else.',
+                '',
+                'If you believe this assignment is outdated, please comment on the issue to discuss before opening a new PR.',
+                '',
+                `Please review our [contributing guidelines](${contributingUrl}) for more details.`,
+              ].join('\n'), 'issue-already-assigned');
+              return;
+            }
+
+            if (hasNoDiscussion) {
+              core.info('Closing PR: no discussion between PR author and a maintainer in the referenced issue.');
+              await closePR([
+                'This PR has been automatically closed. The referenced issue does not show a discussion between you and a maintainer.',
+                '',
+                'To avoid wasted effort on both sides, please discuss your proposed approach in the issue first and wait for a maintainer to respond before opening a PR.',
+                '',
+                `Please review our [contributing guidelines](${contributingUrl}) for more details.`,
+              ].join('\n'), 'missing-maintainer-discussion');
+              return;
+            }
+
+            // If we get here, all issue refs were unfetchable
+            core.info('Could not validate any referenced issues. Closing PR.');
+            await closePR([
+              'This PR has been automatically closed. The referenced issue(s) could not be found.',
+              '',
+              '**Next steps:**',
+              '1. Ensure the issue exists and is in a `getsentry` repository',
+              '2. Discuss the approach with a maintainer in the issue',
+              '3. Once a maintainer has acknowledged your proposed approach, open a new PR referencing the issue',
+              '',
+              `Please review our [contributing guidelines](${contributingUrl}) for more details.`,
+            ].join('\n'), 'missing-issue-reference');
+
+  enforce-draft:
+    name: Enforce Draft PR
+    needs: [validate-non-maintainer-pr]
+    if: |
+      always()
+      && github.event.pull_request.draft == false
+      && needs.validate-non-maintainer-pr.outputs.was-closed != 'true'
+    runs-on: ubuntu-24.04
+    permissions:
+      pull-requests: write
+      contents: write
+    steps:
+      - name: Generate GitHub App token
+        id: app-token
+        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859  # v2
+        with:
+          app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
+          private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}
+
+      - name: Convert PR to draft
+        env:
+          GH_TOKEN: ${{github.token}}
+          PR_URL: ${{ github.event.pull_request.html_url }}
+        run: |
+          gh pr ready "$PR_URL" --undo
+
+      - name: Label and comment
+        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea  # v7.0.1
+        with:
+          github-token: ${{ steps.app-token.outputs.token }}
+          script: |
+            const pullRequest = context.payload.pull_request;
+            const repo = context.repo;
+
+            // Label the PR so maintainers can filter/track violations
+            await github.rest.issues.addLabels({
+              ...repo,
+              issue_number: pullRequest.number,
+              labels: ['converted-to-draft'],
+            });
+
+            // Check for existing bot comment to avoid duplicates on reopen
+            const comments = await github.rest.issues.listComments({
+              ...repo,
+              issue_number: pullRequest.number,
+            });
+            const botComment = comments.data.find(c =>
+              c.user.type === 'Bot' &&
+              c.body.includes('automatically converted to draft')
+            );
+            if (botComment) {
+              core.info('Bot comment already exists, skipping.');
+              return;
+            }
+
+            const contributingUrl = `https://github.com/${repo.owner}/${repo.repo}/blob/${context.payload.repository.default_branch}/CONTRIBUTING.md`;
+
+            await github.rest.issues.createComment({
+              ...repo,
+              issue_number: pullRequest.number,
+              body: [
+                `This PR has been automatically converted to draft. All PRs must start as drafts per our [contributing guidelines](${contributingUrl}).`,
+                '',
+                '**Next steps:**',
+                '1. Ensure CI passes',
+                '2. Fill in the PR description completely',
+                '3. Mark as "Ready for review" when you\'re done'
+              ].join('\n')
+            });

From 8d0496a6538cd0504865dd1e5f4db8a68fe4afd8 Mon Sep 17 00:00:00 2001
From: Stephanie Anderson <stephanie.anderson@sentry.io>
Date: Fri, 27 Mar 2026 20:48:54 +0100
Subject: [PATCH 080/391] chore: Use shared validate-pr composite action
 (#5240)

Replace the inline PR validation workflow with the shared composite action
from getsentry/github-workflows#153.

This shrinks the workflow from 300+ lines to ~15 and ensures future updates
to validation logic are picked up automatically.

#skip-changelog

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/workflows/validate-pr.yml | 315 +-----------------------------
 1 file changed, 2 insertions(+), 313 deletions(-)

diff --git a/.github/workflows/validate-pr.yml b/.github/workflows/validate-pr.yml
index e826cb338a7..c05657993e8 100644
--- a/.github/workflows/validate-pr.yml
+++ b/.github/workflows/validate-pr.yml
@@ -5,323 +5,12 @@ on:
     types: [opened, reopened]
 
 jobs:
-  validate-non-maintainer-pr:
-    name: Validate Non-Maintainer PR
+  validate-pr:
     runs-on: ubuntu-24.04
     permissions:
       pull-requests: write
-      contents: write
-    outputs:
-      was-closed: ${{ steps.validate.outputs.was-closed }}
     steps:
-      - name: Generate GitHub App token
-        id: app-token
-        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859  # v2
+      - uses: getsentry/github-workflows/validate-pr@4243265ac9cc3ee5b89ad2b30c3797ac8483d63a
         with:
           app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
           private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}
-
-      - name: Validate PR
-        id: validate
-        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea  # v7.0.1
-        with:
-          github-token: ${{ steps.app-token.outputs.token }}
-          script: |
-            const pullRequest = context.payload.pull_request;
-            const repo = context.repo;
-            const prAuthor = pullRequest.user.login;
-            const contributingUrl = `https://github.com/${repo.owner}/${repo.repo}/blob/${context.payload.repository.default_branch}/CONTRIBUTING.md`;
-
-            // --- Helper: check if a user has admin or maintain permission on a repo (cached) ---
-            const maintainerCache = new Map();
-            async function isMaintainer(owner, repoName, username) {
-              const key = `${owner}/${repoName}:${username}`;
-              if (maintainerCache.has(key)) return maintainerCache.get(key);
-              let result = false;
-              try {
-                const { data } = await github.rest.repos.getCollaboratorPermissionLevel({
-                  owner,
-                  repo: repoName,
-                  username,
-                });
-                // permission field uses legacy values (admin/write/read/none) where
-                // maintain maps to write. Use role_name for the actual role.
-                result = ['admin', 'maintain'].includes(data.role_name);
-              } catch {
-                // noop — result stays false
-              }
-              maintainerCache.set(key, result);
-              return result;
-            }
-
-            // --- Step 1: Check if PR author is a maintainer (admin or maintain role) ---
-            const authorIsMaintainer = await isMaintainer(repo.owner, repo.repo, prAuthor);
-            if (authorIsMaintainer) {
-              core.info(`PR author ${prAuthor} has admin/maintain access. Skipping.`);
-              return;
-            }
-            core.info(`PR author ${prAuthor} is not a maintainer.`);
-
-            // --- Step 2: Parse issue references from PR body ---
-            const body = pullRequest.body || '';
-
-            // Match all issue reference formats:
-            //   #123, Fixes #123, getsentry/repo#123, Fixes getsentry/repo#123
-            //   https://github.com/getsentry/repo/issues/123
-            const issueRefs = [];
-            const seen = new Set();
-
-            // Pattern 1: Full GitHub URLs
-            const urlPattern = /https?:\/\/github\.com\/(getsentry)\/([\w.-]+)\/issues\/(\d+)/gi;
-            for (const match of body.matchAll(urlPattern)) {
-              const key = `${match[1]}/${match[2]}#${match[3]}`;
-              if (!seen.has(key)) {
-                seen.add(key);
-                issueRefs.push({ owner: match[1], repo: match[2], number: parseInt(match[3]) });
-              }
-            }
-
-            // Pattern 2: Cross-repo references (getsentry/repo#123)
-            const crossRepoPattern = /(?:(?:fix|fixes|fixed|close|closes|closed|resolve|resolves|resolved)\s+)?(getsentry)\/([\w.-]+)#(\d+)/gi;
-            for (const match of body.matchAll(crossRepoPattern)) {
-              const key = `${match[1]}/${match[2]}#${match[3]}`;
-              if (!seen.has(key)) {
-                seen.add(key);
-                issueRefs.push({ owner: match[1], repo: match[2], number: parseInt(match[3]) });
-              }
-            }
-
-            // Pattern 3: Same-repo references (#123)
-            // Negative lookbehind to avoid matching cross-repo refs or URLs already captured
-            const sameRepoPattern = /(?:(?:fix|fixes|fixed|close|closes|closed|resolve|resolves|resolved)\s+)?(?<![/\w])#(\d+)/gi;
-            for (const match of body.matchAll(sameRepoPattern)) {
-              const key = `${repo.owner}/${repo.repo}#${match[1]}`;
-              if (!seen.has(key)) {
-                seen.add(key);
-                issueRefs.push({ owner: repo.owner, repo: repo.repo, number: parseInt(match[1]) });
-              }
-            }
-
-            core.info(`Found ${issueRefs.length} issue reference(s): ${[...seen].join(', ')}`);
-
-            // --- Helper: close PR with comment and labels ---
-            async function closePR(message, reasonLabel) {
-              await github.rest.issues.addLabels({
-                ...repo,
-                issue_number: pullRequest.number,
-                labels: ['violating-contribution-guidelines', reasonLabel],
-              });
-
-              await github.rest.issues.createComment({
-                ...repo,
-                issue_number: pullRequest.number,
-                body: message,
-              });
-
-              await github.rest.pulls.update({
-                ...repo,
-                pull_number: pullRequest.number,
-                state: 'closed',
-              });
-
-              core.setOutput('was-closed', 'true');
-            }
-
-            // --- Step 3: No issue references ---
-            if (issueRefs.length === 0) {
-              core.info('No issue references found. Closing PR.');
-              await closePR([
-                'This PR has been automatically closed. All non-maintainer contributions must reference an existing GitHub issue.',
-                '',
-                '**Next steps:**',
-                '1. Find or open an issue describing the problem or feature',
-                '2. Discuss the approach with a maintainer in the issue',
-                '3. Once a maintainer has acknowledged your proposed approach, open a new PR referencing the issue',
-                '',
-                `Please review our [contributing guidelines](${contributingUrl}) for more details.`,
-              ].join('\n'), 'missing-issue-reference');
-              return;
-            }
-
-            // --- Step 4: Validate each referenced issue ---
-            // A PR is valid if ANY referenced issue passes all checks.
-            let hasAssigneeConflict = false;
-            let hasNoDiscussion = false;
-
-            for (const ref of issueRefs) {
-              core.info(`Checking issue ${ref.owner}/${ref.repo}#${ref.number}...`);
-
-              let issue;
-              try {
-                const { data } = await github.rest.issues.get({
-                  owner: ref.owner,
-                  repo: ref.repo,
-                  issue_number: ref.number,
-                });
-                issue = data;
-              } catch (e) {
-                core.warning(`Could not fetch issue ${ref.owner}/${ref.repo}#${ref.number}: ${e.message}`);
-                continue;
-              }
-
-              // Check assignee: if assigned to someone other than PR author, flag it
-              if (issue.assignees && issue.assignees.length > 0) {
-                const assignedToAuthor = issue.assignees.some(a => a.login === prAuthor);
-                if (!assignedToAuthor) {
-                  core.info(`Issue ${ref.owner}/${ref.repo}#${ref.number} is assigned to someone else.`);
-                  hasAssigneeConflict = true;
-                  continue;
-                }
-              }
-
-              // Check discussion: both PR author and a maintainer must have commented
-              const comments = await github.paginate(github.rest.issues.listComments, {
-                owner: ref.owner,
-                repo: ref.repo,
-                issue_number: ref.number,
-                per_page: 100,
-              });
-
-              // Also consider the issue author as a participant (opening the issue is a form of discussion)
-              // Guard against null user (deleted/suspended GitHub accounts)
-              const prAuthorParticipated =
-                issue.user?.login === prAuthor ||
-                comments.some(c => c.user?.login === prAuthor);
-
-              let maintainerParticipated = false;
-              if (prAuthorParticipated) {
-                // Check each commenter (and issue author) for admin/maintain access on the issue's repo
-                const usersToCheck = new Set();
-                if (issue.user?.login) usersToCheck.add(issue.user.login);
-                for (const comment of comments) {
-                  if (comment.user?.login && comment.user.login !== prAuthor) {
-                    usersToCheck.add(comment.user.login);
-                  }
-                }
-
-                for (const user of usersToCheck) {
-                  if (user === prAuthor) continue;
-                  if (await isMaintainer(repo.owner, repo.repo, user)) {
-                    maintainerParticipated = true;
-                    core.info(`Maintainer ${user} participated in ${ref.owner}/${ref.repo}#${ref.number}.`);
-                    break;
-                  }
-                }
-              }
-
-              if (prAuthorParticipated && maintainerParticipated) {
-                core.info(`Issue ${ref.owner}/${ref.repo}#${ref.number} has valid discussion. PR is allowed.`);
-                return;  // PR is valid — at least one issue passes all checks
-              }
-
-              core.info(`Issue ${ref.owner}/${ref.repo}#${ref.number} lacks discussion between author and maintainer.`);
-              hasNoDiscussion = true;
-            }
-
-            // --- Step 5: No valid issue found — close with the most relevant reason ---
-            if (hasAssigneeConflict) {
-              core.info('Closing PR: referenced issue is assigned to someone else.');
-              await closePR([
-                'This PR has been automatically closed. The referenced issue is already assigned to someone else.',
-                '',
-                'If you believe this assignment is outdated, please comment on the issue to discuss before opening a new PR.',
-                '',
-                `Please review our [contributing guidelines](${contributingUrl}) for more details.`,
-              ].join('\n'), 'issue-already-assigned');
-              return;
-            }
-
-            if (hasNoDiscussion) {
-              core.info('Closing PR: no discussion between PR author and a maintainer in the referenced issue.');
-              await closePR([
-                'This PR has been automatically closed. The referenced issue does not show a discussion between you and a maintainer.',
-                '',
-                'To avoid wasted effort on both sides, please discuss your proposed approach in the issue first and wait for a maintainer to respond before opening a PR.',
-                '',
-                `Please review our [contributing guidelines](${contributingUrl}) for more details.`,
-              ].join('\n'), 'missing-maintainer-discussion');
-              return;
-            }
-
-            // If we get here, all issue refs were unfetchable
-            core.info('Could not validate any referenced issues. Closing PR.');
-            await closePR([
-              'This PR has been automatically closed. The referenced issue(s) could not be found.',
-              '',
-              '**Next steps:**',
-              '1. Ensure the issue exists and is in a `getsentry` repository',
-              '2. Discuss the approach with a maintainer in the issue',
-              '3. Once a maintainer has acknowledged your proposed approach, open a new PR referencing the issue',
-              '',
-              `Please review our [contributing guidelines](${contributingUrl}) for more details.`,
-            ].join('\n'), 'missing-issue-reference');
-
-  enforce-draft:
-    name: Enforce Draft PR
-    needs: [validate-non-maintainer-pr]
-    if: |
-      always()
-      && github.event.pull_request.draft == false
-      && needs.validate-non-maintainer-pr.outputs.was-closed != 'true'
-    runs-on: ubuntu-24.04
-    permissions:
-      pull-requests: write
-      contents: write
-    steps:
-      - name: Generate GitHub App token
-        id: app-token
-        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859  # v2
-        with:
-          app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
-          private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}
-
-      - name: Convert PR to draft
-        env:
-          GH_TOKEN: ${{github.token}}
-          PR_URL: ${{ github.event.pull_request.html_url }}
-        run: |
-          gh pr ready "$PR_URL" --undo
-
-      - name: Label and comment
-        uses: actions/github-script@60a0d83039c74a4aee543508d2ffcb1c3799cdea  # v7.0.1
-        with:
-          github-token: ${{ steps.app-token.outputs.token }}
-          script: |
-            const pullRequest = context.payload.pull_request;
-            const repo = context.repo;
-
-            // Label the PR so maintainers can filter/track violations
-            await github.rest.issues.addLabels({
-              ...repo,
-              issue_number: pullRequest.number,
-              labels: ['converted-to-draft'],
-            });
-
-            // Check for existing bot comment to avoid duplicates on reopen
-            const comments = await github.rest.issues.listComments({
-              ...repo,
-              issue_number: pullRequest.number,
-            });
-            const botComment = comments.data.find(c =>
-              c.user.type === 'Bot' &&
-              c.body.includes('automatically converted to draft')
-            );
-            if (botComment) {
-              core.info('Bot comment already exists, skipping.');
-              return;
-            }
-
-            const contributingUrl = `https://github.com/${repo.owner}/${repo.repo}/blob/${context.payload.repository.default_branch}/CONTRIBUTING.md`;
-
-            await github.rest.issues.createComment({
-              ...repo,
-              issue_number: pullRequest.number,
-              body: [
-                `This PR has been automatically converted to draft. All PRs must start as drafts per our [contributing guidelines](${contributingUrl}).`,
-                '',
-                '**Next steps:**',
-                '1. Ensure CI passes',
-                '2. Fill in the PR description completely',
-                '3. Mark as "Ready for review" when you\'re done'
-              ].join('\n')
-            });

From 5865051197d7944c602a6e0af5e11033709b064d Mon Sep 17 00:00:00 2001
From: Stephanie Anderson <stephanie.anderson@sentry.io>
Date: Fri, 27 Mar 2026 22:48:35 +0100
Subject: [PATCH 081/391] chore: Update validate-pr action to latest version
 (#5241)

Updates the pinned SHA to pick up the bot allowlist fix, which
prevents trusted bots (dependabot, renovate, etc.) from being
closed by the PR validation workflow.

#skip-changelog

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/workflows/validate-pr.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/validate-pr.yml b/.github/workflows/validate-pr.yml
index c05657993e8..3b82dd4026f 100644
--- a/.github/workflows/validate-pr.yml
+++ b/.github/workflows/validate-pr.yml
@@ -10,7 +10,7 @@ jobs:
     permissions:
       pull-requests: write
     steps:
-      - uses: getsentry/github-workflows/validate-pr@4243265ac9cc3ee5b89ad2b30c3797ac8483d63a
+      - uses: getsentry/github-workflows/validate-pr@4ff40ada546d4a31b852a4279828b989a6193497
         with:
           app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
           private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}

From 2166fabd4b23a0e604f6c8ba34b819262c61cb37 Mon Sep 17 00:00:00 2001
From: Stephanie Anderson <stephanie.anderson@sentry.io>
Date: Mon, 30 Mar 2026 12:16:36 +0200
Subject: [PATCH 082/391] fix(ci): Update validate-pr action to remove draft
 enforcement (#5247)

The draft enforcement step was failing due to insufficient app
permissions. It has been removed from the shared action.

Refs getsentry/github-workflows#159

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/workflows/validate-pr.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/validate-pr.yml b/.github/workflows/validate-pr.yml
index 3b82dd4026f..44da67faa43 100644
--- a/.github/workflows/validate-pr.yml
+++ b/.github/workflows/validate-pr.yml
@@ -10,7 +10,7 @@ jobs:
     permissions:
       pull-requests: write
     steps:
-      - uses: getsentry/github-workflows/validate-pr@4ff40ada546d4a31b852a4279828b989a6193497
+      - uses: getsentry/github-workflows/validate-pr@0b52fc6a867b744dcbdf5d25c18bc8d1c95710e1
         with:
           app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
           private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}

From 79a09131975001ac6f291ca8ea011b438431e4e4 Mon Sep 17 00:00:00 2001
From: Stefan Jandl <reg@bitfox.at>
Date: Mon, 30 Mar 2026 14:41:57 +0200
Subject: [PATCH 083/391] feat: Sync file attachments to native (#5211)

---
 CHANGELOG.md                                  | 630 +++++++++---------
 sentry-android-ndk/api/sentry-android-ndk.api |   2 +
 .../sentry/android/ndk/NdkScopeObserver.java  |  38 ++
 .../android/ndk/NdkScopeObserverTest.kt       |  31 +
 sentry/api/sentry.api                         |   4 +
 .../main/java/io/sentry/IScopeObserver.java   |   4 +
 sentry/src/main/java/io/sentry/Scope.java     |   8 +
 .../java/io/sentry/ScopeObserverAdapter.java  |   6 +
 8 files changed, 413 insertions(+), 310 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6f68583a5fe..ac9f9654836 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- Android: Attachments on the scope will now be synced to native ([#5211](https://github.com/getsentry/sentry-java/pull/5211))
+
 ## 8.37.1
 
 ### Fixes
@@ -302,9 +308,8 @@
 - Android: Flush logs when app enters background ([#4951](https://github.com/getsentry/sentry-java/pull/4951))
 - Add option to capture additional OkHttp network request/response details in session replays ([#4919](https://github.com/getsentry/sentry-java/pull/4919))
   - Depends on `SentryOkHttpInterceptor` to intercept the request and extract request/response bodies
-  - To enable, add url regexes via the `io.sentry.session-replay.network-detail-allow-urls` metadata tag in AndroidManifest ([code sample](https://github.com/getsentry/sentry-java/blob/b03edbb1b0d8b871c62a09bc02cbd8a4e1f6fea1/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml#L196-L205))
-    - Or you can manually specify SentryReplayOptions via `SentryAndroid#init`:  
-_(Make sure you disable the auto init via manifest meta-data: io.sentry.auto-init=false)_
+  - To enable, add url regexes via the `io.sentry.session-replay.network-detail-allow-urls` metadata tag in AndroidManifest ([code sample](https://github.com/getsentry/sentry-java/blob/b03edbb1b0d8b871c62a09bc02cbd8a4e1f6fea1/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml#L196-L205)) - Or you can manually specify SentryReplayOptions via `SentryAndroid#init`:
+    _(Make sure you disable the auto init via manifest meta-data: io.sentry.auto-init=false)_
 
 <details>
   <summary>Kotlin</summary>
@@ -346,13 +351,12 @@ SentryAndroid.init(
 
 </details>
 
-
 ### Improvements
 
 - Avoid forking `rootScopes` for Reactor if current thread has `NoOpScopes` ([#4793](https://github.com/getsentry/sentry-java/pull/4793))
   - This reduces the SDKs overhead by avoiding unnecessary scope forks
 
-### Fixes 
+### Fixes
 
 - Fix missing thread stacks for ANRv1 events ([#4918](https://github.com/getsentry/sentry-java/pull/4918))
 - Fix handling of unparseable mime-type on request filter ([#4939](https://github.com/getsentry/sentry-java/pull/4939))
@@ -608,15 +612,15 @@ SentryAndroid.init(
 
 - Add onDiscard to enable users to track the type and amount of data discarded before reaching Sentry ([#4612](https://github.com/getsentry/sentry-java/pull/4612))
   - Stub for setting the callback on `Sentry.init`:
-     ```java
-     Sentry.init(options -> {
-       ...
-       options.setOnDiscard(
-        (reason, category, number) -> {
-          // Your logic to process discarded data
-        });
-     });
-     ```
+    ```java
+    Sentry.init(options -> {
+      ...
+      options.setOnDiscard(
+       (reason, category, number) -> {
+         // Your logic to process discarded data
+       });
+    });
+    ```
 
 ## 8.19.1
 
@@ -666,7 +670,7 @@ SentryAndroid.init(
 - Move and flush unfinished previous session on init ([#4624](https://github.com/getsentry/sentry-java/pull/4624))
   - This removes the need for unnecessary blocking our background queue for 15 seconds in the case of a background app start
 - Switch to compileOnly dependency for compose-ui-material ([#4630](https://github.com/getsentry/sentry-java/pull/4630))
-  - This fixes `StackOverflowError` when using OSS Licenses plugin 
+  - This fixes `StackOverflowError` when using OSS Licenses plugin
 
 ### Dependencies
 
@@ -871,21 +875,24 @@ SentryAndroid.init(
 ### Features
 
 - Add New User Feedback Widget ([#4450](https://github.com/getsentry/sentry-java/pull/4450))
-    - This widget is a custom button that can be used to show the user feedback form
+  - This widget is a custom button that can be used to show the user feedback form
 - Add New User Feedback form ([#4384](https://github.com/getsentry/sentry-java/pull/4384))
-    - We now introduce SentryUserFeedbackDialog, which extends AlertDialog, inheriting the show() and cancel() methods, among others.
-      To use it, just instantiate it and call show() on the instance (Sentry must be previously initialized).
-      For customization options, please check the [User Feedback documentation](https://docs.sentry.io/platforms/android/user-feedback/configuration/).
-      ```java
-      import io.sentry.android.core.SentryUserFeedbackDialog;
-      
-      new SentryUserFeedbackDialog.Builder(context).create().show();
-      ```
-      ```kotlin
-      import io.sentry.android.core.SentryUserFeedbackDialog
-    
-      SentryUserFeedbackDialog.Builder(context).create().show()
-      ```
+  - We now introduce SentryUserFeedbackDialog, which extends AlertDialog, inheriting the show() and cancel() methods, among others.
+    To use it, just instantiate it and call show() on the instance (Sentry must be previously initialized).
+    For customization options, please check the [User Feedback documentation](https://docs.sentry.io/platforms/android/user-feedback/configuration/).
+
+    ```java
+    import io.sentry.android.core.SentryUserFeedbackDialog;
+
+    new SentryUserFeedbackDialog.Builder(context).create().show();
+    ```
+
+    ```kotlin
+    import io.sentry.android.core.SentryUserFeedbackDialog
+
+    SentryUserFeedbackDialog.Builder(context).create().show()
+    ```
+
 - Add `user.id`, `user.name` and `user.email` to log attributes ([#4486](https://github.com/getsentry/sentry-java/pull/4486))
 - User `name` attribute has been deprecated, please use `username` instead ([#4486](https://github.com/getsentry/sentry-java/pull/4486))
 - Add device (`device.brand`, `device.model` and `device.family`) and OS (`os.name` and `os.version`) attributes to logs ([#4493](https://github.com/getsentry/sentry-java/pull/4493))
@@ -931,8 +938,8 @@ SentryAndroid.init(
 ### Features
 
 - Add debug mode for Session Replay masking ([#4357](https://github.com/getsentry/sentry-java/pull/4357))
-    - Use `Sentry.replay().enableDebugMaskingOverlay()` to overlay the screen with the Session Replay masks.
-    - The masks will be invalidated at most once per `frameRate` (default 1 fps).
+  - Use `Sentry.replay().enableDebugMaskingOverlay()` to overlay the screen with the Session Replay masks.
+  - The masks will be invalidated at most once per `frameRate` (default 1 fps).
 - Extend Logs API to allow passing in `attributes` ([#4402](https://github.com/getsentry/sentry-java/pull/4402))
   - `Sentry.logger.log` now takes a `SentryLogParameters`
   - Use `SentryLogParameters.create(SentryAttributes.of(...))` to pass attributes
@@ -963,17 +970,17 @@ SentryAndroid.init(
 ### Features
 
 - Add new User Feedback API ([#4286](https://github.com/getsentry/sentry-java/pull/4286))
-    - We now introduced Sentry.captureFeedback, which supersedes Sentry.captureUserFeedback
+  - We now introduced Sentry.captureFeedback, which supersedes Sentry.captureUserFeedback
 - Add Sentry Log Feature ([#4372](https://github.com/getsentry/sentry-java/pull/4372))
-    - The feature is disabled by default and needs to be enabled by:
-        - `options.getLogs().setEnabled(true)` in `Sentry.init` / `SentryAndroid.init`
-        - `<meta-data android:name="io.sentry.logs.enabled" android:value="true" />` in `AndroidManifest.xml`
-        - `logs.enabled=true` in `sentry.properties`
-        - `sentry.logs.enabled=true` in `application.properties`
-        - `sentry.logs.enabled: true` in `application.yml`
-    - Logs can be captured using `Sentry.logger().info()` and similar methods.
-    - Logs also take a format string and arguments which we then send through `String.format`.
-    - Please use `options.getLogs().setBeforeSend()` to filter outgoing logs
+  - The feature is disabled by default and needs to be enabled by:
+    - `options.getLogs().setEnabled(true)` in `Sentry.init` / `SentryAndroid.init`
+    - `<meta-data android:name="io.sentry.logs.enabled" android:value="true" />` in `AndroidManifest.xml`
+    - `logs.enabled=true` in `sentry.properties`
+    - `sentry.logs.enabled=true` in `application.properties`
+    - `sentry.logs.enabled: true` in `application.yml`
+  - Logs can be captured using `Sentry.logger().info()` and similar methods.
+  - Logs also take a format string and arguments which we then send through `String.format`.
+  - Please use `options.getLogs().setBeforeSend()` to filter outgoing logs
 
 ### Fixes
 
@@ -1008,11 +1015,11 @@ SentryAndroid.init(
 ### Features
 
 - Wrap configured OpenTelemetry `ContextStorageProvider` if available ([#4359](https://github.com/getsentry/sentry-java/pull/4359))
-  - This is only relevant if you see `java.lang.IllegalStateException: Found multiple ContextStorageProvider. Set the io.opentelemetry.context.ContextStorageProvider property to the fully qualified class name of the provider to use. Falling back to default ContextStorage. Found providers: ...` 
+  - This is only relevant if you see `java.lang.IllegalStateException: Found multiple ContextStorageProvider. Set the io.opentelemetry.context.ContextStorageProvider property to the fully qualified class name of the provider to use. Falling back to default ContextStorage. Found providers: ...`
   - Set `-Dio.opentelemetry.context.contextStorageProvider=io.sentry.opentelemetry.SentryContextStorageProvider` on your `java` command
   - Sentry will then wrap the other `ContextStorageProvider` that has been configured by loading it through SPI
   - If no other `ContextStorageProvider` is available or there are problems loading it, we fall back to using `SentryOtelThreadLocalStorage`
-    
+
 ### Fixes
 
 - Update profile chunk rate limit and client report ([#4353](https://github.com/getsentry/sentry-java/pull/4353))
@@ -1071,9 +1078,9 @@ SentryAndroid.init(
 - UI Profiling GA
 
   Continuous Profiling is now GA, named UI Profiling. To enable it you can use one of the following options. More info can be found at https://docs.sentry.io/platforms/android/profiling/.
-    Note: Both `options.profilesSampler` and `options.profilesSampleRate` must **not** be set to enable UI Profiling.
-    To keep the same transaction-based behaviour, without the 30 seconds limitation, you can use the `trace` lifecycle mode.
-  
+  Note: Both `options.profilesSampler` and `options.profilesSampleRate` must **not** be set to enable UI Profiling.
+  To keep the same transaction-based behaviour, without the 30 seconds limitation, you can use the `trace` lifecycle mode.
+
   ```xml
   <application>
     <!-- Enable UI profiling, adjust in production env. This is evaluated only once per session -->
@@ -1084,10 +1091,11 @@ SentryAndroid.init(
     <meta-data android:name="io.sentry.traces.profiling.start-on-app-start" android:value="true" />
   </application>
   ```
+
   ```java
   import io.sentry.ProfileLifecycle;
   import io.sentry.android.core.SentryAndroid;
-  
+
   SentryAndroid.init(context, options -> {
       // Enable UI profiling, adjust in production env. This is evaluated only once per session
       options.setProfileSessionSampleRate(1.0);
@@ -1097,6 +1105,7 @@ SentryAndroid.init(
       options.setStartProfilerOnAppStart(true);
     });
   ```
+
   ```kotlin
   import io.sentry.ProfileLifecycle
   import io.sentry.android.core.SentryAndroid
@@ -1167,10 +1176,10 @@ SentryAndroid.init(
 ### Features
 
 - Add native stack frame address information and debug image metadata to ANR events ([#4061](https://github.com/getsentry/sentry-java/pull/4061))
-    - This enables symbolication for stripped native code in ANRs
+  - This enables symbolication for stripped native code in ANRs
 - Add Continuous Profiling Support ([#3710](https://github.com/getsentry/sentry-java/pull/3710))
 
-  To enable Continuous Profiling use the `Sentry.startProfiler` and `Sentry.stopProfiler` experimental APIs. Sampling rate can be set through `options.profileSessionSampleRate`, which defaults to null (disabled).   
+  To enable Continuous Profiling use the `Sentry.startProfiler` and `Sentry.stopProfiler` experimental APIs. Sampling rate can be set through `options.profileSessionSampleRate`, which defaults to null (disabled).
   Note: Both `options.profilesSampler` and `options.profilesSampleRate` must **not** be set to enable Continuous Profiling.
 
   ```java
@@ -1178,7 +1187,7 @@ SentryAndroid.init(
   import io.sentry.android.core.SentryAndroid;
 
   SentryAndroid.init(context) { options ->
-   
+
     // Currently under experimental options:
     options.getExperimental().setProfileSessionSampleRate(1.0);
     // In manual mode, you need to start and stop the profiler manually using Sentry.startProfiler and Sentry.stopProfiler
@@ -1187,16 +1196,17 @@ SentryAndroid.init(
   }
   // Start profiling
   Sentry.startProfiler();
-  
+
   // After all profiling is done, stop the profiler. Profiles can last indefinitely if not stopped.
   Sentry.stopProfiler();
   ```
+
   ```kotlin
   import io.sentry.ProfileLifecycle
   import io.sentry.android.core.SentryAndroid
 
   SentryAndroid.init(context) { options ->
-   
+
     // Currently under experimental options:
     options.experimental.profileSessionSampleRate = 1.0
     // In manual mode, you need to start and stop the profiler manually using Sentry.startProfiler and Sentry.stopProfiler
@@ -1205,7 +1215,7 @@ SentryAndroid.init(
   }
   // Start profiling
   Sentry.startProfiler()
-  
+
   // After all profiling is done, stop the profiler. Profiles can last indefinitely if not stopped.
   Sentry.stopProfiler()
   ```
@@ -1243,7 +1253,7 @@ SentryAndroid.init(
     - remove 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
+  - Please ensure the SentryOkHttpInterceptor is added last to your OkHttpClient, as otherwise changes to the `Request` by subsequent interceptors won't be considered
 - Fix "class ch.qos.logback.classic.spi.ThrowableProxyVO cannot be cast to class ch.qos.logback.classic.spi.ThrowableProxy" ([#4206](https://github.com/getsentry/sentry-java/pull/4206))
   - In this case we cannot report the `Throwable` to Sentry as it's not available
   - If you are using OpenTelemetry v1 `OpenTelemetryAppender`, please consider upgrading to v2
@@ -1316,7 +1326,7 @@ SentryAndroid.init(
 ### Behavioural Changes
 
 - The class `io.sentry.spring.jakarta.webflux.ReactorUtils` is now deprecated, please use `io.sentry.reactor.SentryReactorUtils` in the new `sentry-reactor` module instead ([#4155](https://github.com/getsentry/sentry-java/pull/4155))
-  - The new module will be exposed as an `api` dependency when using `sentry-spring-boot-jakarta` (Spring Boot 3) or `sentry-spring-jakarta` (Spring 6). 
+  - The new module will be exposed as an `api` dependency when using `sentry-spring-boot-jakarta` (Spring Boot 3) or `sentry-spring-jakarta` (Spring 6).
     Therefore, if you're using one of those modules, changing your imports will suffice.
 
 ## 8.2.0
@@ -1330,7 +1340,7 @@ SentryAndroid.init(
 - Create onCreate and onStart spans for all Activities ([#4025](https://github.com/getsentry/sentry-java/pull/4025))
 - Add split apks info to the `App` context ([#3193](https://github.com/getsentry/sentry-java/pull/3193))
 - Expose new `withSentryObservableEffect` method overload that accepts `SentryNavigationListener` as a parameter ([#4143](https://github.com/getsentry/sentry-java/pull/4143))
-  - This allows sharing the same `SentryNavigationListener` instance across fragments and composables to preserve the trace 
+  - This allows sharing the same `SentryNavigationListener` instance across fragments and composables to preserve the trace
 - (Internal) Add API to filter native debug images based on stacktrace addresses ([#4089](https://github.com/getsentry/sentry-java/pull/4089))
 - Propagate sampling random value ([#4153](https://github.com/getsentry/sentry-java/pull/4153))
   - The random value used for sampling traces is now sent to Sentry and attached to the `baggage` header on outgoing requests
@@ -1401,6 +1411,7 @@ SentryAndroid.init(context) { options ->
 ```
 
 If you would like to keep some of the default broadcast events as breadcrumbs, consider opening a [GitHub issue](https://github.com/getsentry/sentry-java/issues/new).
+
 - Set mechanism `type` to `suppressed` for suppressed exceptions ([#4125](https://github.com/getsentry/sentry-java/pull/4125))
   - This helps to distinguish an exceptions cause from any suppressed exceptions in the Sentry UI
 
@@ -1422,10 +1433,10 @@ Version 8 of the Sentry Android/Java SDK brings a variety of features and fixes.
 - Lifecycle tokens have been introduced to manage `Scope` lifecycle, see "Behavioural Changes" for more details.
 - Bumping `minSdk` level to 21 (Android 5.0)
 - Our `sentry-opentelemetry-agent` has been improved and now works in combination with the rest of Sentry. You may now combine OpenTelemetry and Sentry for instrumenting your application.
-    - You may now use both OpenTelemetry SDK and Sentry SDK to capture transactions and spans. They can also be mixed and end up on the same transaction.
-    - OpenTelemetry extends the Sentry SDK by adding spans for numerous integrations, like Ktor, Vert.x and MongoDB. Please check [the OpenTelemetry GitHub repository](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation) for a full list.
-    - OpenTelemetry allows propagating trace information from and to additional libraries, that Sentry did not support before, for example gRPC.
-    - OpenTelemetry also has broader support for propagating the Sentry `Scopes` through reactive libraries like RxJava.
+  - You may now use both OpenTelemetry SDK and Sentry SDK to capture transactions and spans. They can also be mixed and end up on the same transaction.
+  - OpenTelemetry extends the Sentry SDK by adding spans for numerous integrations, like Ktor, Vert.x and MongoDB. Please check [the OpenTelemetry GitHub repository](https://github.com/open-telemetry/opentelemetry-java-instrumentation/tree/main/instrumentation) for a full list.
+  - OpenTelemetry allows propagating trace information from and to additional libraries, that Sentry did not support before, for example gRPC.
+  - OpenTelemetry also has broader support for propagating the Sentry `Scopes` through reactive libraries like RxJava.
 - The SDK is now compatible with Spring Boot 3.4
 - We now support GraphQL v22 (`sentry-graphql-22`)
 - Metrics have been removed
@@ -1442,11 +1453,11 @@ This SDK version is compatible with a self-hosted version of Sentry `22.12.0` or
 - The minSdk level for sentry-android-ndk changed from 19 to 21 ([#3851](https://github.com/getsentry/sentry-java/pull/3851))
 - Throw IllegalArgumentException when calling Sentry.init on Android ([#3596](https://github.com/getsentry/sentry-java/pull/3596))
 - Metrics have been removed from the SDK ([#3774](https://github.com/getsentry/sentry-java/pull/3774))
-    - Metrics will return but we don't know in what exact form yet
+  - Metrics will return but we don't know in what exact form yet
 - `enableTracing` option (a.k.a `enable-tracing`) has been removed from the SDK ([#3776](https://github.com/getsentry/sentry-java/pull/3776))
-    - Please set `tracesSampleRate` to a value >= 0.0 for enabling performance instead. The default value is `null` which means performance is disabled.
+  - Please set `tracesSampleRate` to a value >= 0.0 for enabling performance instead. The default value is `null` which means performance is disabled.
 - Replace `synchronized` methods and blocks with `ReentrantLock` (`AutoClosableReentrantLock`) ([#3715](https://github.com/getsentry/sentry-java/pull/3715))
-    - If you are subclassing any Sentry classes, please check if the parent class used `synchronized` before. Please make sure to use the same lock object as the parent class in that case.
+  - If you are subclassing any Sentry classes, please check if the parent class used `synchronized` before. Please make sure to use the same lock object as the parent class in that case.
 - `traceOrigins` option (`io.sentry.traces.tracing-origins` in manifest) has been removed, please use `tracePropagationTargets` (`io.sentry.traces.trace-propagation-targets` in manifest`) instead ([#3780](https://github.com/getsentry/sentry-java/pull/3780))
 - `profilingEnabled` option (`io.sentry.traces.profiling.enable` in manifest) has been removed, please use `profilesSampleRate` (`io.sentry.traces.profiling.sample-rate` instead) instead ([#3780](https://github.com/getsentry/sentry-java/pull/3780))
 - `shutdownTimeout` option has been removed, please use `shutdownTimeoutMillis` instead ([#3780](https://github.com/getsentry/sentry-java/pull/3780))
@@ -1466,32 +1477,32 @@ This SDK version is compatible with a self-hosted version of Sentry `22.12.0` or
 - User segment has been removed ([#3512](https://github.com/getsentry/sentry-java/pull/3512))
 - One of the `AndroidTransactionProfiler` constructors has been removed, please use a different one ([#3780](https://github.com/getsentry/sentry-java/pull/3780))
 - Use String instead of UUID for SessionId ([#3834](https://github.com/getsentry/sentry-java/pull/3834))
-    - The `Session` constructor now takes a `String` instead of a `UUID` for the `sessionId` parameter.
-    - `Session.getSessionId()` now returns a `String` instead of a `UUID`.
+  - The `Session` constructor now takes a `String` instead of a `UUID` for the `sessionId` parameter.
+  - `Session.getSessionId()` now returns a `String` instead of a `UUID`.
 - All status codes below 400 are now mapped to `SpanStatus.OK` ([#3869](https://github.com/getsentry/sentry-java/pull/3869))
 - Change OkHttp sub-spans to span attributes ([#3556](https://github.com/getsentry/sentry-java/pull/3556))
-    - This will reduce the number of spans created by the SDK
+  - This will reduce the number of spans created by the SDK
 - `instrumenter` option should no longer be needed as our new OpenTelemetry integration now works in combination with the rest of Sentry
 
 ### Behavioural Changes
 
 - We're introducing some new `Scope` types in the SDK, allowing for better control over what data is attached where. Previously there was a stack of scopes that was pushed and popped. Instead we now fork scopes for a given lifecycle and then restore the previous scopes. Since `Hub` is gone, it is also never cloned anymore. Separation of data now happens through the different scope types while making it easier to manipulate exactly what you need without having to attach data at the right time to have it apply where wanted.
-    - Global scope is attached to all events created by the SDK. It can also be modified before `Sentry.init` has been called. It can be manipulated using `Sentry.configureScope(ScopeType.GLOBAL, (scope) -> { ... })`.
-    - Isolation scope can be used e.g. to attach data to all events that come up while handling an incoming request. It can also be used for other isolation purposes. It can be manipulated using `Sentry.configureScope(ScopeType.ISOLATION, (scope) -> { ... })`. The SDK automatically forks isolation scope in certain cases like incoming requests, CRON jobs, Spring `@Async` and more.
-    - Current scope is forked often and data added to it is only added to events that are created while this scope is active. Data is also passed on to newly forked child scopes but not to parents. It can be manipulated using `Sentry.configureScope(ScopeType.CURRENT, (scope) -> { ... })`.
+  - Global scope is attached to all events created by the SDK. It can also be modified before `Sentry.init` has been called. It can be manipulated using `Sentry.configureScope(ScopeType.GLOBAL, (scope) -> { ... })`.
+  - Isolation scope can be used e.g. to attach data to all events that come up while handling an incoming request. It can also be used for other isolation purposes. It can be manipulated using `Sentry.configureScope(ScopeType.ISOLATION, (scope) -> { ... })`. The SDK automatically forks isolation scope in certain cases like incoming requests, CRON jobs, Spring `@Async` and more.
+  - Current scope is forked often and data added to it is only added to events that are created while this scope is active. Data is also passed on to newly forked child scopes but not to parents. It can be manipulated using `Sentry.configureScope(ScopeType.CURRENT, (scope) -> { ... })`.
 - `Sentry.popScope` has been deprecated, please call `.close()` on the token returned by `Sentry.pushScope` instead or use it in a way described in more detail in [our migration guide](https://docs.sentry.io/platforms/java/migration/7.x-to-8.0).
 - We have chosen a default scope that is used for `Sentry.configureScope()` as well as API like `Sentry.setTag()`
-    - For Android the type defaults to `CURRENT` scope
-    - For Backend and other JVM applicatons it defaults to `ISOLATION` scope
+  - For Android the type defaults to `CURRENT` scope
+  - For Backend and other JVM applicatons it defaults to `ISOLATION` scope
 - Event processors on `Scope` can now be ordered by overriding the `getOrder` method on implementations of `EventProcessor`. NOTE: This order only applies to event processors on `Scope` but not `SentryOptions` at the moment. Feel free to request this if you need it.
 - `Hub` is deprecated in favor of `Scopes`, alongside some `Hub` relevant APIs. More details can be found in [our migration guide](https://docs.sentry.io/platforms/java/migration/7.x-to-8.0).
 - Send file name and path only if `isSendDefaultPii` is `true` ([#3919](https://github.com/getsentry/sentry-java/pull/3919))
 - (Android) Enable Performance V2 by default ([#3824](https://github.com/getsentry/sentry-java/pull/3824))
-    - With this change cold app start spans will include spans for ContentProviders, Application and Activity load.
+  - With this change cold app start spans will include spans for ContentProviders, Application and Activity load.
 - (Android) Replace thread id with kernel thread id in span data ([#3706](https://github.com/getsentry/sentry-java/pull/3706))
 - (Android) The JNI layer for sentry-native has now been moved from sentry-java to sentry-native ([#3189](https://github.com/getsentry/sentry-java/pull/3189))
-    - This now includes prefab support for sentry-native, allowing you to link and access the sentry-native API within your native app code
-    - Checkout the `sentry-samples/sentry-samples-android` example on how to configure CMake and consume `sentry.h`
+  - This now includes prefab support for sentry-native, allowing you to link and access the sentry-native API within your native app code
+  - Checkout the `sentry-samples/sentry-samples-android` example on how to configure CMake and consume `sentry.h`
 - The user ip-address is now only set to `"{{auto}}"` if `sendDefaultPii` is enabled ([#4072](https://github.com/getsentry/sentry-java/pull/4072))
   - This change gives you control over IP address collection directly on the client
 
@@ -1499,49 +1510,49 @@ This SDK version is compatible with a self-hosted version of Sentry `22.12.0` or
 
 - The SDK is now compatible with Spring Boot 3.4 ([#3939](https://github.com/getsentry/sentry-java/pull/3939))
 - Our `sentry-opentelemetry-agent` has been completely reworked and now plays nicely with the rest of the Java SDK
-    - You may also want to give this new agent a try even if you haven't used OpenTelemetry (with Sentry) before. It offers support for [many more libraries and frameworks](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md), improving on our trace propagation, `Scopes` (used to be `Hub`) propagation as well as performance instrumentation (i.e. more spans).
-    - If you are using a framework we did not support before and currently resort to manual instrumentation, please give the agent a try. See [here for a list of supported libraries, frameworks and application servers](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md).
-    - Please see [Java SDK docs](https://docs.sentry.io/platforms/java/tracing/instrumentation/opentelemetry/) for more details on how to set up the agent. Please make sure to select the correct SDK from the dropdown on the left side of the docs.
-    - What's new about the Agent
-        - When the OpenTelemetry Agent is used, Sentry API creates OpenTelemetry spans under the hood, handing back a wrapper object which bridges the gap between traditional Sentry API and OpenTelemetry. We might be replacing some of the Sentry performance API in the future.
-            - This is achieved by configuring the SDK to use `OtelSpanFactory` instead of `DefaultSpanFactory` which is done automatically by the auto init of the Java Agent.
-        - OpenTelemetry spans are now only turned into Sentry spans when they are finished so they can be sent to the Sentry server.
-        - Now registers an OpenTelemetry `Sampler` which uses Sentry sampling configuration
-        - Other Performance integrations automatically stop creating spans to avoid duplicate spans
-        - The Sentry SDK now makes use of OpenTelemetry `Context` for storing Sentry `Scopes` (which is similar to what used to be called `Hub`) and thus relies on OpenTelemetry for `Context` propagation.
-        - Classes used for the previous version of our OpenTelemetry support have been deprecated but can still be used manually. We're not planning to keep the old agent around in favor of less complexity in the SDK.
+  - You may also want to give this new agent a try even if you haven't used OpenTelemetry (with Sentry) before. It offers support for [many more libraries and frameworks](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md), improving on our trace propagation, `Scopes` (used to be `Hub`) propagation as well as performance instrumentation (i.e. more spans).
+  - If you are using a framework we did not support before and currently resort to manual instrumentation, please give the agent a try. See [here for a list of supported libraries, frameworks and application servers](https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/docs/supported-libraries.md).
+  - Please see [Java SDK docs](https://docs.sentry.io/platforms/java/tracing/instrumentation/opentelemetry/) for more details on how to set up the agent. Please make sure to select the correct SDK from the dropdown on the left side of the docs.
+  - What's new about the Agent
+    - When the OpenTelemetry Agent is used, Sentry API creates OpenTelemetry spans under the hood, handing back a wrapper object which bridges the gap between traditional Sentry API and OpenTelemetry. We might be replacing some of the Sentry performance API in the future.
+      - This is achieved by configuring the SDK to use `OtelSpanFactory` instead of `DefaultSpanFactory` which is done automatically by the auto init of the Java Agent.
+    - OpenTelemetry spans are now only turned into Sentry spans when they are finished so they can be sent to the Sentry server.
+    - Now registers an OpenTelemetry `Sampler` which uses Sentry sampling configuration
+    - Other Performance integrations automatically stop creating spans to avoid duplicate spans
+    - The Sentry SDK now makes use of OpenTelemetry `Context` for storing Sentry `Scopes` (which is similar to what used to be called `Hub`) and thus relies on OpenTelemetry for `Context` propagation.
+    - Classes used for the previous version of our OpenTelemetry support have been deprecated but can still be used manually. We're not planning to keep the old agent around in favor of less complexity in the SDK.
 - Add `sentry-opentelemetry-agentless-spring` module ([#4000](https://github.com/getsentry/sentry-java/pull/4000))
-    - This module can be added as a dependency when using Sentry with OpenTelemetry and Spring Boot but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.
-    - You may want to set `OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none` env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.
+  - This module can be added as a dependency when using Sentry with OpenTelemetry and Spring Boot but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.
+  - You may want to set `OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none` env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.
 - Add `sentry-opentelemetry-agentless` module ([#3961](https://github.com/getsentry/sentry-java/pull/3961))
-    - This module can be added as a dependency when using Sentry with OpenTelemetry but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.
-    - To enable the auto configuration of it, please set `-Dotel.java.global-autoconfigure.enabled=true` on the `java` command, when starting your application.
-    - You may also want to set `OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none` env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.
+  - This module can be added as a dependency when using Sentry with OpenTelemetry but don't want to use our Agent. It takes care of configuring OpenTelemetry for use with Sentry.
+  - To enable the auto configuration of it, please set `-Dotel.java.global-autoconfigure.enabled=true` on the `java` command, when starting your application.
+  - You may also want to set `OTEL_LOGS_EXPORTER=none;OTEL_METRICS_EXPORTER=none;OTEL_TRACES_EXPORTER=none` env vars to not have the log flooded with error messages regarding OpenTelemetry features we don't use.
 - `OpenTelemetryUtil.applyOpenTelemetryOptions` now takes an enum instead of a boolean for its mode
 - Add `openTelemetryMode` option ([#3994](https://github.com/getsentry/sentry-java/pull/3994))
-    - It defaults to `AUTO` meaning the SDK will figure out how to best configure itself for use with OpenTelemetry
-    - Use of OpenTelemetry can also be disabled completely by setting it to `OFF` ([#3995](https://github.com/getsentry/sentry-java/pull/3995))
-        - In this case even if OpenTelemetry is present, the Sentry SDK will not use it
-    - Use `AGENT` when using `sentry-opentelemetry-agent`
-    - Use `AGENTLESS` when using `sentry-opentelemetry-agentless`
-    - Use `AGENTLESS_SPRING` when using `sentry-opentelemetry-agentless-spring`
+  - It defaults to `AUTO` meaning the SDK will figure out how to best configure itself for use with OpenTelemetry
+  - Use of OpenTelemetry can also be disabled completely by setting it to `OFF` ([#3995](https://github.com/getsentry/sentry-java/pull/3995))
+    - In this case even if OpenTelemetry is present, the Sentry SDK will not use it
+  - Use `AGENT` when using `sentry-opentelemetry-agent`
+  - Use `AGENTLESS` when using `sentry-opentelemetry-agentless`
+  - Use `AGENTLESS_SPRING` when using `sentry-opentelemetry-agentless-spring`
 - Add `ignoredTransactions` option to filter out transactions by name ([#3871](https://github.com/getsentry/sentry-java/pull/3871))
-    - can be used via ENV vars, e.g. `SENTRY_IGNORED_TRANSACTIONS=POST /person/,GET /pers.*`
-    - can also be set in options directly, e.g. `options.setIgnoredTransactions(...)`
-    - can also be set in `sentry.properties`, e.g. `ignored-transactions=POST /person/,GET /pers.*`
-    - can also be set in Spring config `application.properties`, e.g. `sentry.ignored-transactions=POST /person/,GET /pers.*`
+  - can be used via ENV vars, e.g. `SENTRY_IGNORED_TRANSACTIONS=POST /person/,GET /pers.*`
+  - can also be set in options directly, e.g. `options.setIgnoredTransactions(...)`
+  - can also be set in `sentry.properties`, e.g. `ignored-transactions=POST /person/,GET /pers.*`
+  - can also be set in Spring config `application.properties`, e.g. `sentry.ignored-transactions=POST /person/,GET /pers.*`
 - Add `scopeBindingMode` to `SpanOptions` ([#4004](https://github.com/getsentry/sentry-java/pull/4004))
-    - This setting only affects the SDK when used with OpenTelemetry.
-    - Defaults to `AUTO` meaning the SDK will decide whether the span should be bound to the current scope. It will not bind transactions to scope using `AUTO`, it will only bind spans where the parent span is on the current scope.
-    - `ON` sets the new span on the current scope.
-    - `OFF` does not set the new span on the scope.
+  - This setting only affects the SDK when used with OpenTelemetry.
+  - Defaults to `AUTO` meaning the SDK will decide whether the span should be bound to the current scope. It will not bind transactions to scope using `AUTO`, it will only bind spans where the parent span is on the current scope.
+  - `ON` sets the new span on the current scope.
+  - `OFF` does not set the new span on the scope.
 - Add `ignoredSpanOrigins` option for ignoring spans coming from certain integrations
-    - We pre-configure this to ignore Performance instrumentation for Spring and other integrations when using our OpenTelemetry Agent to avoid duplicate spans
+  - We pre-configure this to ignore Performance instrumentation for Spring and other integrations when using our OpenTelemetry Agent to avoid duplicate spans
 - Support `graphql-java` v22 via a new module `sentry-graphql-22` ([#3740](https://github.com/getsentry/sentry-java/pull/3740))
-    - If you are using `graphql-java` v21 or earlier, you can use the `sentry-graphql` module
-    - For `graphql-java` v22 and newer please use the `sentry-graphql-22` module
+  - If you are using `graphql-java` v21 or earlier, you can use the `sentry-graphql` module
+  - For `graphql-java` v22 and newer please use the `sentry-graphql-22` module
 - We now provide a `SentryInstrumenter` bean directly for Spring (Boot) if there is none yet instead of using `GraphQlSourceBuilderCustomizer` to add the instrumentation ([#3744](https://github.com/getsentry/sentry-java/pull/3744))
-    - It is now also possible to provide a bean of type `SentryGraphqlInstrumentation.BeforeSpanCallback` which is then used by `SentryInstrumenter`
+  - It is now also possible to provide a bean of type `SentryGraphqlInstrumentation.BeforeSpanCallback` which is then used by `SentryInstrumenter`
 - Add data fetching environment hint to breadcrumb for GraphQL (#3413) ([#3431](https://github.com/getsentry/sentry-java/pull/3431))
 - Report exceptions returned by Throwable.getSuppressed() to Sentry as exception groups ([#3396] https://github.com/getsentry/sentry-java/pull/3396)
   - Any suppressed exceptions are added to the issue details page in Sentry, the same way any cause is.
@@ -1549,23 +1560,23 @@ This SDK version is compatible with a self-hosted version of Sentry `22.12.0` or
 - Enable `ThreadLocalAccessor` for Spring Boot 3 WebFlux by default ([#4023](https://github.com/getsentry/sentry-java/pull/4023))
 - Allow passing `environment` to `CheckinUtils.withCheckIn` ([3889](https://github.com/getsentry/sentry-java/pull/3889))
 - Add `globalHubMode` to options ([#3805](https://github.com/getsentry/sentry-java/pull/3805))
-    - `globalHubMode` used to only be a param on `Sentry.init`. To make it easier to be used in e.g. Desktop environments, we now additionally added it as an option on SentryOptions that can also be set via `sentry.properties`.
-    - If both the param on `Sentry.init` and the option are set, the option will win. By default the option is set to `null` meaning whatever is passed to `Sentry.init` takes effect.
+  - `globalHubMode` used to only be a param on `Sentry.init`. To make it easier to be used in e.g. Desktop environments, we now additionally added it as an option on SentryOptions that can also be set via `sentry.properties`.
+  - If both the param on `Sentry.init` and the option are set, the option will win. By default the option is set to `null` meaning whatever is passed to `Sentry.init` takes effect.
 - Lazy uuid generation for SentryId and SpanId ([#3770](https://github.com/getsentry/sentry-java/pull/3770))
 - Faster generation of Sentry and Span IDs ([#3818](https://github.com/getsentry/sentry-java/pull/3818))
-    - Uses faster implementation to convert UUID to SentryID String
-    - Uses faster Random implementation to generate UUIDs
+  - Uses faster implementation to convert UUID to SentryID String
+  - Uses faster Random implementation to generate UUIDs
 - Android 15: Add support for 16KB page sizes ([#3851](https://github.com/getsentry/sentry-java/pull/3851))
-    - See https://developer.android.com/guide/practices/page-sizes for more details
+  - See https://developer.android.com/guide/practices/page-sizes for more details
 - Add init priority settings ([#3674](https://github.com/getsentry/sentry-java/pull/3674))
-    - You may now set `forceInit=true` (`force-init` for `.properties` files) to ensure a call to Sentry.init / SentryAndroid.init takes effect
+  - You may now set `forceInit=true` (`force-init` for `.properties` files) to ensure a call to Sentry.init / SentryAndroid.init takes effect
 - Add force init option to Android Manifest ([#3675](https://github.com/getsentry/sentry-java/pull/3675))
-    - Use `<meta-data android:name="io.sentry.force-init" android:value="true" />` to ensure Sentry Android auto init is not easily overwritten
+  - Use `<meta-data android:name="io.sentry.force-init" android:value="true" />` to ensure Sentry Android auto init is not easily overwritten
 - Attach request body for `application/x-www-form-urlencoded` requests in Spring ([#3731](https://github.com/getsentry/sentry-java/pull/3731))
-    - Previously request body was only attached for `application/json` requests
+  - Previously request body was only attached for `application/json` requests
 - Set breadcrumb level based on http status ([#3771](https://github.com/getsentry/sentry-java/pull/3771))
 - Emit transaction.data inside contexts.trace.data ([#3735](https://github.com/getsentry/sentry-java/pull/3735))
-    - Also does not emit `transaction.data` in `extras` anymore
+  - Also does not emit `transaction.data` in `extras` anymore
 - Add a sample for showcasing Sentry with OpenTelemetry for Spring Boot 3 with our Java agent (`sentry-samples-spring-boot-jakarta-opentelemetry`) ([#3856](https://github.com/getsentry/sentry-java/pull/3828))
 - Add a sample for showcasing Sentry with OpenTelemetry for Spring Boot 3 without our Java agent (`sentry-samples-spring-boot-jakarta-opentelemetry-noagent`) ([#3856](https://github.com/getsentry/sentry-java/pull/3856))
 - Add a sample for showcasing Sentry with OpenTelemetry (`sentry-samples-console-opentelemetry-noagent`) ([#3856](https://github.com/getsentry/sentry-java/pull/3862))
@@ -1573,28 +1584,28 @@ This SDK version is compatible with a self-hosted version of Sentry `22.12.0` or
 ### Fixes
 
 - Fix incoming defer sampling decision `sentry-trace` header ([#3942](https://github.com/getsentry/sentry-java/pull/3942))
-    - A `sentry-trace` header that only contains trace ID and span ID but no sampled flag (`-1`, `-0` suffix) means the receiving system can make its own sampling decision
-    - When generating `sentry-trace` header from `PropagationContext` we now copy the `sampled` flag.
-    - In `TransactionContext.fromPropagationContext` when there is no parent sampling decision, keep the decision `null` so a new sampling decision is made instead of defaulting to `false`
+  - A `sentry-trace` header that only contains trace ID and span ID but no sampled flag (`-1`, `-0` suffix) means the receiving system can make its own sampling decision
+  - When generating `sentry-trace` header from `PropagationContext` we now copy the `sampled` flag.
+  - In `TransactionContext.fromPropagationContext` when there is no parent sampling decision, keep the decision `null` so a new sampling decision is made instead of defaulting to `false`
 - Fix order of calling `close` on previous Sentry instance when re-initializing ([#3750](https://github.com/getsentry/sentry-java/pull/3750))
-    - Previously some parts of Sentry were immediately closed after re-init that should have stayed open and some parts of the previous init were never closed
+  - Previously some parts of Sentry were immediately closed after re-init that should have stayed open and some parts of the previous init were never closed
 - All status codes below 400 are now mapped to `SpanStatus.OK` ([#3869](https://github.com/getsentry/sentry-java/pull/3869))
 - Improve ignored check performance ([#3992](https://github.com/getsentry/sentry-java/pull/3992))
-    - Checking if a span origin, a transaction or a checkIn should be ignored is now faster
+  - Checking if a span origin, a transaction or a checkIn should be ignored is now faster
 - Cache requests for Spring using Springs `ContentCachingRequestWrapper` instead of our own Wrapper to also cache parameters ([#3641](https://github.com/getsentry/sentry-java/pull/3641))
-    - Previously only the body was cached which could lead to problems in the FilterChain as Request parameters were not available
+  - Previously only the body was cached which could lead to problems in the FilterChain as Request parameters were not available
 - Close backpressure monitor on SDK shutdown ([#3998](https://github.com/getsentry/sentry-java/pull/3998))
-    - Due to the backpressure monitor rescheduling a task to run every 10s, it very likely caused shutdown to wait the full `shutdownTimeoutMillis` (defaulting to 2s) instead of being able to terminate immediately
+  - Due to the backpressure monitor rescheduling a task to run every 10s, it very likely caused shutdown to wait the full `shutdownTimeoutMillis` (defaulting to 2s) instead of being able to terminate immediately
 - Let OpenTelemetry auto instrumentation handle extracting and injecting tracing information if present ([#3953](https://github.com/getsentry/sentry-java/pull/3953))
-    - Our integrations no longer call `.continueTrace` and also do not inject tracing headers if the integration has been added to `ignoredSpanOrigins`
+  - Our integrations no longer call `.continueTrace` and also do not inject tracing headers if the integration has been added to `ignoredSpanOrigins`
 - Fix testTag not working for Jetpack Compose user interaction tracking ([#3878](https://github.com/getsentry/sentry-java/pull/3878))
 - Mark `DiskFlushNotification` hint flushed when rate limited ([#3892](https://github.com/getsentry/sentry-java/pull/3892))
-    - Our `UncaughtExceptionHandlerIntegration` waited for the full flush timeout duration (default 15s) when rate limited.
+  - Our `UncaughtExceptionHandlerIntegration` waited for the full flush timeout duration (default 15s) when rate limited.
 - Do not replace `op` with auto generated content for OpenTelemetry spans with span kind `INTERNAL` ([#3906](https://github.com/getsentry/sentry-java/pull/3906))
 - Add `enable-spotlight` and `spotlight-connection-url` to external options and check if spotlight is enabled when deciding whether to inspect an OpenTelemetry span for connecting to splotlight ([#3709](https://github.com/getsentry/sentry-java/pull/3709))
 - Trace context on `Contexts.setTrace` has been marked `@NotNull` ([#3721](https://github.com/getsentry/sentry-java/pull/3721))
-    - Setting it to `null` would cause an exception.
-    - Transactions are dropped if trace context is missing
+  - Setting it to `null` would cause an exception.
+  - Transactions are dropped if trace context is missing
 - Remove internal annotation on `SpanOptions` ([#3722](https://github.com/getsentry/sentry-java/pull/3722))
 - `SentryLogbackInitializer` is now public ([#3723](https://github.com/getsentry/sentry-java/pull/3723))
 - Parse and use `send-default-pii` and `max-request-body-size` from `sentry.properties` ([#3534](https://github.com/getsentry/sentry-java/pull/3534))
@@ -1611,66 +1622,66 @@ These changes have been made during development of `8.0.0`. You may skip this se
 
 - Extract OpenTelemetry `URL_PATH` span attribute into description ([#3933](https://github.com/getsentry/sentry-java/pull/3933))
 - Replace OpenTelemetry `ContextStorage` wrapper with `ContextStorageProvider` ([#3938](https://github.com/getsentry/sentry-java/pull/3938))
-    - The wrapper had to be put in place before any call to `Context` whereas `ContextStorageProvider` is automatically invoked at the correct time.
+  - The wrapper had to be put in place before any call to `Context` whereas `ContextStorageProvider` is automatically invoked at the correct time.
 - Send `otel.kind` to Sentry ([#3907](https://github.com/getsentry/sentry-java/pull/3907))
 - Spring Boot now automatically detects if OpenTelemetry is available and makes use of it ([#3846](https://github.com/getsentry/sentry-java/pull/3846))
-    - This is only enabled if there is no OpenTelemetry agent available
-    - We prefer to use the OpenTelemetry agent as it offers more auto instrumentation
-    - In some cases the OpenTelemetry agent cannot be used, please see https://opentelemetry.io/docs/zero-code/java/spring-boot-starter/ for more details on when to prefer the Agent and when the Spring Boot starter makes more sense.
-    - In this mode the SDK makes use of the `OpenTelemetry` bean that is created by `opentelemetry-spring-boot-starter` instead of `GlobalOpenTelemetry`
+  - This is only enabled if there is no OpenTelemetry agent available
+  - We prefer to use the OpenTelemetry agent as it offers more auto instrumentation
+  - In some cases the OpenTelemetry agent cannot be used, please see https://opentelemetry.io/docs/zero-code/java/spring-boot-starter/ for more details on when to prefer the Agent and when the Spring Boot starter makes more sense.
+  - In this mode the SDK makes use of the `OpenTelemetry` bean that is created by `opentelemetry-spring-boot-starter` instead of `GlobalOpenTelemetry`
 - Spring Boot now automatically detects our OpenTelemetry agent if its auto init is disabled ([#3848](https://github.com/getsentry/sentry-java/pull/3848))
-    - This means Spring Boot config mechanisms can now be combined with our OpenTelemetry agent
-    - The `sentry-opentelemetry-extra` module has been removed again, most classes have been moved to `sentry-opentelemetry-bootstrap` which is loaded into the bootstrap classloader (i.e. `null`) when our Java agent is used. The rest has been moved into `sentry-opentelemetry-agentcustomization` and is loaded into the agent classloader when our Java agent is used.
-    - The `sentry-opentelemetry-bootstrap` and `sentry-opentelemetry-agentcustomization` modules can be used without the agent as well, in which case all classes are loaded into the application classloader. Check out our `sentry-samples-spring-boot-jakarta-opentelemetry-noagent` sample.
-    - In this mode the SDK makes use of `GlobalOpenTelemetry`
+  - This means Spring Boot config mechanisms can now be combined with our OpenTelemetry agent
+  - The `sentry-opentelemetry-extra` module has been removed again, most classes have been moved to `sentry-opentelemetry-bootstrap` which is loaded into the bootstrap classloader (i.e. `null`) when our Java agent is used. The rest has been moved into `sentry-opentelemetry-agentcustomization` and is loaded into the agent classloader when our Java agent is used.
+  - The `sentry-opentelemetry-bootstrap` and `sentry-opentelemetry-agentcustomization` modules can be used without the agent as well, in which case all classes are loaded into the application classloader. Check out our `sentry-samples-spring-boot-jakarta-opentelemetry-noagent` sample.
+  - In this mode the SDK makes use of `GlobalOpenTelemetry`
 - Automatically set span factory based on presence of OpenTelemetry ([#3858](https://github.com/getsentry/sentry-java/pull/3858))
-    - `SentrySpanFactoryHolder` has been removed as it is no longer required.
+  - `SentrySpanFactoryHolder` has been removed as it is no longer required.
 
 - Replace deprecated `SimpleInstrumentation` with `SimplePerformantInstrumentation` for graphql 22 ([#3974](https://github.com/getsentry/sentry-java/pull/3974))
 - We now hold a strong reference to the underlying OpenTelemetry span when it is created through Sentry API ([#3997](https://github.com/getsentry/sentry-java/pull/3997))
-    - This keeps it from being garbage collected too early
+  - This keeps it from being garbage collected too early
 - Defer sampling decision by setting `sampled` to `null` in `PropagationContext` when using OpenTelemetry in case of an incoming defer sampling `sentry-trace` header. ([#3945](https://github.com/getsentry/sentry-java/pull/3945))
 - Build `PropagationContext` from `SamplingDecision` made by `SentrySampler` instead of parsing headers and potentially ignoring a sampling decision in case a `sentry-trace` header comes in with deferred sampling decision. ([#3947](https://github.com/getsentry/sentry-java/pull/3947))
 - The Sentry OpenTelemetry Java agent now makes sure Sentry `Scopes` storage is initialized even if the agents auto init is disabled ([#3848](https://github.com/getsentry/sentry-java/pull/3848))
-    - This is required for all integrations to work together with our OpenTelemetry Java agent if its auto init has been disabled and the SDKs init should be used instead.
+  - This is required for all integrations to work together with our OpenTelemetry Java agent if its auto init has been disabled and the SDKs init should be used instead.
 - Fix `startChild` for span that is not in current OpenTelemetry `Context` ([#3862](https://github.com/getsentry/sentry-java/pull/3862))
-    - Starting a child span from a transaction that wasn't in the current `Context` lead to multiple transactions being created (one for the transaction and another per span created).
+  - Starting a child span from a transaction that wasn't in the current `Context` lead to multiple transactions being created (one for the transaction and another per span created).
 - Add `auto.graphql.graphql22` to ignored span origins when using OpenTelemetry ([#3828](https://github.com/getsentry/sentry-java/pull/3828))
 - Use OpenTelemetry span name as fallback for transaction name ([#3557](https://github.com/getsentry/sentry-java/pull/3557))
-    - In certain cases we were sending transactions as "<unlabeled transaction>" when using OpenTelemetry
+  - In certain cases we were sending transactions as "<unlabeled transaction>" when using OpenTelemetry
 - Add OpenTelemetry span data to Sentry span ([#3593](https://github.com/getsentry/sentry-java/pull/3593))
 - No longer selectively copy OpenTelemetry attributes to Sentry spans / transactions `data` ([#3663](https://github.com/getsentry/sentry-java/pull/3663))
 - Remove `PROCESS_COMMAND_ARGS` (`process.command_args`) OpenTelemetry span attribute as it can be very large ([#3664](https://github.com/getsentry/sentry-java/pull/3664))
 - Use RECORD_ONLY sampling decision if performance is disabled ([#3659](https://github.com/getsentry/sentry-java/pull/3659))
-    - Also fix check whether Performance is enabled when making a sampling decision in the OpenTelemetry sampler
+  - Also fix check whether Performance is enabled when making a sampling decision in the OpenTelemetry sampler
 - Sentry OpenTelemetry Java Agent now sets Instrumenter to SENTRY (used to be OTEL) ([#3697](https://github.com/getsentry/sentry-java/pull/3697))
 - Set span origin in `ActivityLifecycleIntegration` on span options instead of after creating the span / transaction ([#3702](https://github.com/getsentry/sentry-java/pull/3702))
-    - This allows spans to be filtered by span origin on creation
+  - This allows spans to be filtered by span origin on creation
 - Honor ignored span origins in `SentryTracer.startChild` ([#3704](https://github.com/getsentry/sentry-java/pull/3704))
 - Use span id of remote parent ([#3548](https://github.com/getsentry/sentry-java/pull/3548))
-    - Traces were broken because on an incoming request, OtelSentrySpanProcessor did not set the parentSpanId on the span correctly. Traces were not referencing the actual parent span but some other (random) span ID which the server doesn't know.
+  - Traces were broken because on an incoming request, OtelSentrySpanProcessor did not set the parentSpanId on the span correctly. Traces were not referencing the actual parent span but some other (random) span ID which the server doesn't know.
 - Attach active span to scope when using OpenTelemetry ([#3549](https://github.com/getsentry/sentry-java/pull/3549))
-    - Errors weren't linked to traces correctly due to parts of the SDK not knowing the current span
+  - Errors weren't linked to traces correctly due to parts of the SDK not knowing the current span
 - Record dropped spans in client report when sampling out OpenTelemetry spans ([#3552](https://github.com/getsentry/sentry-java/pull/3552))
 - Retrieve the correct current span from `Scope`/`Scopes` when using OpenTelemetry ([#3554](https://github.com/getsentry/sentry-java/pull/3554))
 - Support spans that are split into multiple batches ([#3539](https://github.com/getsentry/sentry-java/pull/3539))
-    - When spans belonging to a single transaction were split into multiple batches for SpanExporter, we did not add all spans because the isSpanTooOld check wasn't inverted.
+  - When spans belonging to a single transaction were split into multiple batches for SpanExporter, we did not add all spans because the isSpanTooOld check wasn't inverted.
 - Partially fix bootstrap class loading ([#3543](https://github.com/getsentry/sentry-java/pull/3543))
-    - There was a problem with two separate Sentry `Scopes` being active inside each OpenTelemetry `Context` due to using context keys from more than one class loader.
+  - There was a problem with two separate Sentry `Scopes` being active inside each OpenTelemetry `Context` due to using context keys from more than one class loader.
 - The Spring Boot 3 WebFlux sample now uses our GraphQL v22 integration ([#3828](https://github.com/getsentry/sentry-java/pull/3828))
 - Do not ignore certain span origins for OpenTelemetry without agent ([#3856](https://github.com/getsentry/sentry-java/pull/3856))
 - `span.startChild` now uses `.makeCurrent()` by default ([#3544](https://github.com/getsentry/sentry-java/pull/3544))
-    - This caused an issue where the span tree wasn't correct because some spans were not added to their direct parent
+  - This caused an issue where the span tree wasn't correct because some spans were not added to their direct parent
 - Do not set the exception group marker when there is a suppressed exception ([#4056](https://github.com/getsentry/sentry-java/pull/4056))
-    - Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.
-    - As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.
-    - We are planning to improve this in the future but opted for this fix first.
+  - Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.
+  - As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.
+  - We are planning to improve this in the future but opted for this fix first.
 
 ### Dependencies
 
 - Bump Native SDK from v0.7.0 to v0.7.17 ([#3441](https://github.com/getsentry/sentry-java/pull/3189)) ([#3851](https://github.com/getsentry/sentry-java/pull/3851)) ([#3914](https://github.com/getsentry/sentry-java/pull/3914)) ([#4003](https://github.com/getsentry/sentry-java/pull/4003))
-    - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0717)
-    - [diff](https://github.com/getsentry/sentry-native/compare/0.7.0...0.7.17)
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0717)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.7.0...0.7.17)
 - Bump OpenTelemetry to 1.44.1, OpenTelemetry Java Agent to 2.10.0 and Semantic Conventions to 1.28.0 ([#3668](https://github.com/getsentry/sentry-java/pull/3668)) ([#3935](https://github.com/getsentry/sentry-java/pull/3935))
 
 ### Migration Guide / Deprecations
@@ -1678,10 +1689,10 @@ These changes have been made during development of `8.0.0`. You may skip this se
 Please take a look at [our migration guide in docs](https://docs.sentry.io/platforms/java/migration/7.x-to-8.0).
 
 - `Hub` has been deprecated, we're replacing the following:
-    - `IHub` has been replaced by `IScopes`, however you should be able to simply pass `IHub` instances to code expecting `IScopes`, allowing for an easier migration.
-    - `HubAdapter.getInstance()` has been replaced by `ScopesAdapter.getInstance()`
-    - The `.clone()` method on `IHub`/`IScopes` has been deprecated, please use `.pushScope()` or `.pushIsolationScope()` instead
-    - Some internal methods like `.getCurrentHub()` and `.setCurrentHub()` have also been replaced.
+  - `IHub` has been replaced by `IScopes`, however you should be able to simply pass `IHub` instances to code expecting `IScopes`, allowing for an easier migration.
+  - `HubAdapter.getInstance()` has been replaced by `ScopesAdapter.getInstance()`
+  - The `.clone()` method on `IHub`/`IScopes` has been deprecated, please use `.pushScope()` or `.pushIsolationScope()` instead
+  - Some internal methods like `.getCurrentHub()` and `.setCurrentHub()` have also been replaced.
 - `Sentry.popScope` has been replaced by calling `.close()` on the token returned by `Sentry.pushScope()` and `Sentry.pushIsolationScope()`. The token can also be used in a `try` block like this:
 
 ```
@@ -1692,28 +1703,27 @@ try (final @NotNull ISentryLifecycleToken ignored = Sentry.pushScope()) {
 
 as well as:
 
-
 ```
 try (final @NotNull ISentryLifecycleToken ignored = Sentry.pushIsolationScope()) {
   // this block has its separate isolation scope
 }
 ```
+
 - Classes used by our previous OpenTelemetry integration have been deprecated (`SentrySpanProcessor`, `SentryPropagator`, `OpenTelemetryLinkErrorEventProcessor`). Please take a look at [docs](https://docs.sentry.io/platforms/java/tracing/instrumentation/opentelemetry/) on how to setup OpenTelemetry in v8.
 
 You may also use `LifecycleHelper.close(token)`, e.g. in case you need to pass the token around for closing later.
 
-
 ### Changes from `rc.4`
 
 If you have been using `8.0.0-rc.4` of the Java SDK, here's the new changes that have been included in the `8.0.0` release:
 
 - Make `SentryClient` constructor public ([#4045](https://github.com/getsentry/sentry-java/pull/4045))
 - The user ip-address is now only set to `"{{auto}}"` if sendDefaultPii is enabled ([#4072](https://github.com/getsentry/sentry-java/pull/4072))
-    - This change gives you control over IP address collection directly on the client
+  - This change gives you control over IP address collection directly on the client
 - Do not set the exception group marker when there is a suppressed exception ([#4056](https://github.com/getsentry/sentry-java/pull/4056))
-    - Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.
-    - As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.
-    - We are planning to improve this in the future but opted for this fix first.
+  - Due to how grouping works in Sentry currently sometimes the suppressed exception is treated as the main exception. This change ensures we keep using the main exception and not change how grouping works.
+  - As a consequence the list of exceptions in the group on top of an issue is no longer shown in Sentry UI.
+  - We are planning to improve this in the future but opted for this fix first.
 - Fix swallow NDK loadLibrary errors ([#4082](https://github.com/getsentry/sentry-java/pull/4082))
 
 ## 7.22.6
@@ -1724,7 +1734,7 @@ If you have been using `8.0.0-rc.4` of the Java SDK, here's the new changes that
 - Improve low memory breadcrumb capturing ([#4325](https://github.com/getsentry/sentry-java/pull/4325))
 - Make `SystemEventsBreadcrumbsIntegration` faster ([#4330](https://github.com/getsentry/sentry-java/pull/4330))
 - Fix unregister `SystemEventsBroadcastReceiver` when entering background ([#4338](https://github.com/getsentry/sentry-java/pull/4338))
-    - This should reduce ANRs seen with this class in the stack trace for Android 14 and above
+  - This should reduce ANRs seen with this class in the stack trace for Android 14 and above
 - Pre-load modules on a background thread upon SDK init ([#4348](https://github.com/getsentry/sentry-java/pull/4348))
 - Session Replay: Fix inconsistent `segment_id` ([#4471](https://github.com/getsentry/sentry-java/pull/4471))
 - Session Replay: Do not capture current replay for cached events from the past ([#4474](https://github.com/getsentry/sentry-java/pull/4474))
@@ -1772,11 +1782,11 @@ If you have been using `8.0.0-rc.4` of the Java SDK, here's the new changes that
 ### Fixes
 
 - Session Replay: Fix various crashes and issues ([#4135](https://github.com/getsentry/sentry-java/pull/4135))
-    - Fix `FileNotFoundException` when trying to read/write `.ongoing_segment` file
-    - Fix `IllegalStateException` when registering `onDrawListener`
-    - Fix SIGABRT native crashes on Motorola devices when encoding a video
+  - Fix `FileNotFoundException` when trying to read/write `.ongoing_segment` file
+  - Fix `IllegalStateException` when registering `onDrawListener`
+  - Fix SIGABRT native crashes on Motorola devices when encoding a video
 - (Jetpack Compose) Modifier.sentryTag now uses Modifier.Node ([#4029](https://github.com/getsentry/sentry-java/pull/4029))
-    - This allows Composables that use this modifier to be skippable
+  - This allows Composables that use this modifier to be skippable
 
 ## 7.21.0
 
@@ -1790,7 +1800,7 @@ If you have been using `8.0.0-rc.4` of the Java SDK, here's the new changes that
 ### Behavioural Changes
 
 - (changed in [7.20.1](https://github.com/getsentry/sentry-java/releases/tag/7.20.1)) The user ip-address is now only set to `"{{auto}}"` if sendDefaultPii is enabled ([#4071](https://github.com/getsentry/sentry-java/pull/4071))
-    - This change gives you control over IP address collection directly on the client
+  - This change gives you control over IP address collection directly on the client
 - Reduce the number of broadcasts the SDK is subscribed for ([#4052](https://github.com/getsentry/sentry-java/pull/4052))
   - Drop `TempSensorBreadcrumbsIntegration`
   - Drop `PhoneStateBreadcrumbsIntegration`
@@ -1839,7 +1849,7 @@ If you would like to keep some of the default broadcast events as breadcrumbs, c
 ### Behavioural Changes
 
 - The user ip-address is now only set to `"{{auto}}"` if sendDefaultPii is enabled ([#4071](https://github.com/getsentry/sentry-java/pull/4071))
-    - This change gives you control over IP address collection directly on the client
+  - This change gives you control over IP address collection directly on the client
 
 ## 7.20.0
 
@@ -1849,23 +1859,23 @@ If you would like to keep some of the default broadcast events as breadcrumbs, c
 
 To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onErrorSampleRate` options.
 
-  ```kotlin
-  import io.sentry.SentryReplayOptions
-  import io.sentry.android.core.SentryAndroid
+```kotlin
+import io.sentry.SentryReplayOptions
+import io.sentry.android.core.SentryAndroid
 
-  SentryAndroid.init(context) { options ->
-   
-    options.sessionReplay.sessionSampleRate = 1.0
-    options.sessionReplay.onErrorSampleRate = 1.0
-  
-    // To change default redaction behavior (defaults to true)
-    options.sessionReplay.redactAllImages = true
-    options.sessionReplay.redactAllText = true
-  
-    // To change quality of the recording (defaults to MEDIUM)
-    options.sessionReplay.quality = SentryReplayOptions.SentryReplayQuality.MEDIUM // (LOW|MEDIUM|HIGH)
-  }
-  ```
+SentryAndroid.init(context) { options ->
+
+  options.sessionReplay.sessionSampleRate = 1.0
+  options.sessionReplay.onErrorSampleRate = 1.0
+
+  // To change default redaction behavior (defaults to true)
+  options.sessionReplay.redactAllImages = true
+  options.sessionReplay.redactAllText = true
+
+  // To change quality of the recording (defaults to MEDIUM)
+  options.sessionReplay.quality = SentryReplayOptions.SentryReplayQuality.MEDIUM // (LOW|MEDIUM|HIGH)
+}
+```
 
 ### Fixes
 
@@ -1899,16 +1909,16 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 ### Fixes
 
 - Session Replay: fix various crashes and issues ([#3970](https://github.com/getsentry/sentry-java/pull/3970))
-    - Fix `IndexOutOfBoundsException` when tracking window changes
-    - Fix `IllegalStateException` when adding/removing draw listener for a dead view
-    - Fix `ConcurrentModificationException` when registering window listeners and stopping `WindowRecorder`/`GestureRecorder`
+  - Fix `IndexOutOfBoundsException` when tracking window changes
+  - Fix `IllegalStateException` when adding/removing draw listener for a dead view
+  - Fix `ConcurrentModificationException` when registering window listeners and stopping `WindowRecorder`/`GestureRecorder`
 - Add support for setting sentry-native handler_strategy ([#3671](https://github.com/getsentry/sentry-java/pull/3671))
 
 ### Dependencies
 
 - Bump Native SDK from v0.7.8 to v0.7.16 ([#3671](https://github.com/getsentry/sentry-java/pull/3671))
-    - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0716)
-    - [diff](https://github.com/getsentry/sentry-native/compare/0.7.8...0.7.16)
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0716)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.7.8...0.7.16)
 
 ## 7.18.1
 
@@ -1921,7 +1931,7 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 ### Features
 
 - Android 15: Add support for 16KB page sizes ([#3620](https://github.com/getsentry/sentry-java/pull/3620))
-    - See https://developer.android.com/guide/practices/page-sizes for more details
+  - See https://developer.android.com/guide/practices/page-sizes for more details
 - Session Replay: Add `beforeSendReplay` callback ([#3855](https://github.com/getsentry/sentry-java/pull/3855))
 - Session Replay: Add support for masking/unmasking view containers ([#3881](https://github.com/getsentry/sentry-java/pull/3881))
 
@@ -1930,14 +1940,14 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 - Avoid collecting normal frames ([#3782](https://github.com/getsentry/sentry-java/pull/3782))
 - Ensure android initialization process continues even if options configuration block throws an exception ([#3887](https://github.com/getsentry/sentry-java/pull/3887))
 - Do not report parsing ANR error when there are no threads ([#3888](https://github.com/getsentry/sentry-java/pull/3888))
-    - This should significantly reduce the number of events with message "Sentry Android SDK failed to parse system thread dump..." reported
+  - This should significantly reduce the number of events with message "Sentry Android SDK failed to parse system thread dump..." reported
 - Session Replay: Disable replay in session mode when rate limit is active ([#3854](https://github.com/getsentry/sentry-java/pull/3854))
 
 ### Dependencies
 
 - Bump Native SDK from v0.7.2 to v0.7.8 ([#3620](https://github.com/getsentry/sentry-java/pull/3620))
-    - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#078)
-    - [diff](https://github.com/getsentry/sentry-native/compare/0.7.2...0.7.8)
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#078)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.7.2...0.7.8)
 
 ## 7.17.0
 
@@ -1951,8 +1961,8 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 - Using MaxBreadcrumb with value 0 no longer crashes. ([#3836](https://github.com/getsentry/sentry-java/pull/3836))
 - Accept manifest integer values when requiring floating values ([#3823](https://github.com/getsentry/sentry-java/pull/3823))
 - Fix standalone tomcat jndi issue ([#3873](https://github.com/getsentry/sentry-java/pull/3873))
-    - Using Sentry Spring Boot on a standalone tomcat caused the following error:
-        - Failed to bind properties under 'sentry.parsed-dsn' to io.sentry.Dsn
+  - Using Sentry Spring Boot on a standalone tomcat caused the following error:
+    - Failed to bind properties under 'sentry.parsed-dsn' to io.sentry.Dsn
 
 ## 7.16.0
 
@@ -1976,7 +1986,7 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 
 ### Breaking changes
 
-- The method `addIntegrationToSdkVersion(Ljava/lang/Class;)V` has been removed from the core (`io.sentry:sentry`) package. Please make sure all of the packages (e.g. `io.sentry:sentry-android-core`, `io.sentry:sentry-android-fragment`, `io.sentry:sentry-okhttp`  and others) are all aligned and using the same version to prevent the `NoSuchMethodError` exception.
+- The method `addIntegrationToSdkVersion(Ljava/lang/Class;)V` has been removed from the core (`io.sentry:sentry`) package. Please make sure all of the packages (e.g. `io.sentry:sentry-android-core`, `io.sentry:sentry-android-fragment`, `io.sentry:sentry-okhttp` and others) are all aligned and using the same version to prevent the `NoSuchMethodError` exception.
 
 ## 7.16.0-alpha.1
 
@@ -2003,12 +2013,12 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 - Add support for `feedback` envelope header item type ([#3687](https://github.com/getsentry/sentry-java/pull/3687))
 - Add breadcrumb.origin field ([#3727](https://github.com/getsentry/sentry-java/pull/3727))
 - Session Replay: Add options to selectively mask/unmask views captured in replay. The following options are available: ([#3689](https://github.com/getsentry/sentry-java/pull/3689))
-    - `android:tag="sentry-mask|sentry-unmask"` in XML or `view.setTag("sentry-mask|sentry-unmask")` in code tags
-        - if you already have a tag set for a view, you can set a tag by id: `<tag android:id="@id/sentry_privacy" android:value="mask|unmask"/>` in XML or `view.setTag(io.sentry.android.replay.R.id.sentry_privacy, "mask|unmask")` in code
-    - `view.sentryReplayMask()` or `view.sentryReplayUnmask()` extension functions
-    - mask/unmask `View`s of a certain type by adding fully-qualified classname to one of the lists `options.experimental.sessionReplay.addMaskViewClass()` or `options.experimental.sessionReplay.addUnmaskViewClass()`. Note, that all of the view subclasses/subtypes will be masked/unmasked as well
-        - For example, (this is already a default behavior) to mask all `TextView`s and their subclasses (`RadioButton`, `EditText`, etc.): `options.experimental.sessionReplay.addMaskViewClass("android.widget.TextView")`
-        - If you're using code obfuscation, adjust your proguard-rules accordingly, so your custom view class name is not minified
+  - `android:tag="sentry-mask|sentry-unmask"` in XML or `view.setTag("sentry-mask|sentry-unmask")` in code tags
+    - if you already have a tag set for a view, you can set a tag by id: `<tag android:id="@id/sentry_privacy" android:value="mask|unmask"/>` in XML or `view.setTag(io.sentry.android.replay.R.id.sentry_privacy, "mask|unmask")` in code
+  - `view.sentryReplayMask()` or `view.sentryReplayUnmask()` extension functions
+  - mask/unmask `View`s of a certain type by adding fully-qualified classname to one of the lists `options.experimental.sessionReplay.addMaskViewClass()` or `options.experimental.sessionReplay.addUnmaskViewClass()`. Note, that all of the view subclasses/subtypes will be masked/unmasked as well
+    - For example, (this is already a default behavior) to mask all `TextView`s and their subclasses (`RadioButton`, `EditText`, etc.): `options.experimental.sessionReplay.addMaskViewClass("android.widget.TextView")`
+    - If you're using code obfuscation, adjust your proguard-rules accordingly, so your custom view class name is not minified
 - Session Replay: Support Jetpack Compose masking ([#3739](https://github.com/getsentry/sentry-java/pull/3739))
   - To selectively mask/unmask @Composables, use `Modifier.sentryReplayMask()` and `Modifier.sentryReplayUnmask()` modifiers
 - Session Replay: Mask `WebView`, `VideoView` and `androidx.media3.ui.PlayerView` by default ([#3775](https://github.com/getsentry/sentry-java/pull/3775))
@@ -2022,7 +2032,7 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 - Fix potential ANRs due to default integrations ([#3778](https://github.com/getsentry/sentry-java/pull/3778))
 - Lazily initialize heavy `SentryOptions` members to avoid ANRs on app start ([#3749](https://github.com/getsentry/sentry-java/pull/3749))
 
-*Breaking changes*:
+_Breaking changes_:
 
 - `options.experimental.sessionReplay.errorSampleRate` was renamed to `options.experimental.sessionReplay.onErrorSampleRate` ([#3637](https://github.com/getsentry/sentry-java/pull/3637))
 - Manifest option `io.sentry.session-replay.error-sample-rate` was renamed to `io.sentry.session-replay.on-error-sample-rate` ([#3637](https://github.com/getsentry/sentry-java/pull/3637))
@@ -2092,15 +2102,15 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
   import io.sentry.android.core.SentryAndroid
 
   SentryAndroid.init(context) { options ->
-   
+
     // Currently under experimental options:
     options.experimental.sessionReplay.sessionSampleRate = 1.0
     options.experimental.sessionReplay.errorSampleRate = 1.0
-  
+
     // To change default redaction behavior (defaults to true)
     options.experimental.sessionReplay.redactAllImages = true
     options.experimental.sessionReplay.redactAllText = true
-  
+
     // To change quality of the recording (defaults to MEDIUM)
     options.experimental.sessionReplay.quality = SentryReplayOptions.SentryReplayQuality.MEDIUM // (LOW|MEDIUM|HIGH)
   }
@@ -2189,7 +2199,7 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 
 ### Features
 
-- Experimental: Add support for Sentry Developer Metrics ([#3205](https://github.com/getsentry/sentry-java/pull/3205), [#3238](https://github.com/getsentry/sentry-java/pull/3238), [#3248](https://github.com/getsentry/sentry-java/pull/3248), [#3250](https://github.com/getsentry/sentry-java/pull/3250))  
+- Experimental: Add support for Sentry Developer Metrics ([#3205](https://github.com/getsentry/sentry-java/pull/3205), [#3238](https://github.com/getsentry/sentry-java/pull/3238), [#3248](https://github.com/getsentry/sentry-java/pull/3248), [#3250](https://github.com/getsentry/sentry-java/pull/3250))
   Use the Metrics API to track processing time, download sizes, user signups, and conversion rates and correlate them back to tracing data in order to get deeper insights and solve issues faster. Our API supports counters, distributions, sets, gauges and timers, and it's easy to get started:
   ```kotlin
   Sentry.metrics()
@@ -2233,8 +2243,8 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 - (perf-v2): Calculate frame delay on a span level ([#3197](https://github.com/getsentry/sentry-java/pull/3197))
 - Resolve spring properties in @SentryCheckIn annotation ([#3194](https://github.com/getsentry/sentry-java/pull/3194))
 - Experimental: Add Spotlight integration ([#3166](https://github.com/getsentry/sentry-java/pull/3166))
-    - For more details about Spotlight head over to https://spotlightjs.com/
-    - Set `options.isEnableSpotlight = true` to enable Spotlight
+  - For more details about Spotlight head over to https://spotlightjs.com/
+  - Set `options.isEnableSpotlight = true` to enable Spotlight
 
 ### Fixes
 
@@ -2248,12 +2258,12 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 ### Features
 
 - Added App Start profiling
-    - This depends on the new option `io.sentry.profiling.enable-app-start`, other than the already existing `io.sentry.traces.profiling.sample-rate`.
-    - Sampler functions can check the new `isForNextAppStart` flag, to adjust startup profiling sampling programmatically.
-      Relevant PRs:
-    - Decouple Profiler from Transaction ([#3101](https://github.com/getsentry/sentry-java/pull/3101))
-    - Add options and sampling logic ([#3121](https://github.com/getsentry/sentry-java/pull/3121))
-    - Add ContentProvider and start profile ([#3128](https://github.com/getsentry/sentry-java/pull/3128))
+  - This depends on the new option `io.sentry.profiling.enable-app-start`, other than the already existing `io.sentry.traces.profiling.sample-rate`.
+  - Sampler functions can check the new `isForNextAppStart` flag, to adjust startup profiling sampling programmatically.
+    Relevant PRs:
+  - Decouple Profiler from Transaction ([#3101](https://github.com/getsentry/sentry-java/pull/3101))
+  - Add options and sampling logic ([#3121](https://github.com/getsentry/sentry-java/pull/3121))
+  - Add ContentProvider and start profile ([#3128](https://github.com/getsentry/sentry-java/pull/3128))
 - Extend internal performance collector APIs ([#3102](https://github.com/getsentry/sentry-java/pull/3102))
 - Collect slow and frozen frames for spans using `OnFrameMetricsAvailableListener` ([#3111](https://github.com/getsentry/sentry-java/pull/3111))
 - Interpolate total frame count to match span duration ([#3158](https://github.com/getsentry/sentry-java/pull/3158))
@@ -2335,8 +2345,9 @@ To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.onE
 ## 7.0.0
 
 Version 7 of the Sentry Android/Java SDK brings a variety of features and fixes. The most notable changes are:
+
 - Bumping `minSdk` level to 19 (Android 4.4)
-- The SDK will now listen to connectivity changes and try to re-upload cached events when internet connection is re-established additionally to uploading events on app restart 
+- The SDK will now listen to connectivity changes and try to re-upload cached events when internet connection is re-established additionally to uploading events on app restart
 - `Sentry.getSpan` now returns the root transaction, which should improve the span hierarchy and make it leaner
 - Multiple improvements to reduce probability of the SDK causing ANRs
 - New `sentry-okhttp` artifact is unbundled from Android and can be used in pure JVM-only apps
@@ -2370,8 +2381,8 @@ Similarly, if you have a Sentry SDK (e.g. `sentry-android-core`) dependency on o
 - `SentryOkHttpUtils` was removed from public API as it's been exposed by mistake ([#3005](https://github.com/getsentry/sentry-java/pull/3005))
 - `Scope` now implements the `IScope` interface, therefore some methods like `ScopeCallback.run` accept `IScope` now ([#3066](https://github.com/getsentry/sentry-java/pull/3066))
 - Cleanup `startTransaction` overloads ([#2964](https://github.com/getsentry/sentry-java/pull/2964))
-    - We have reduced the number of overloads by allowing to pass in a `TransactionOptions` object instead of having separate parameters for certain options
-    - `TransactionOptions` has defaults set and can be customized, for example:
+  - We have reduced the number of overloads by allowing to pass in a `TransactionOptions` object instead of having separate parameters for certain options
+  - `TransactionOptions` has defaults set and can be customized, for example:
 
 ```kotlin
 // old
@@ -2384,14 +2395,14 @@ val transaction = Sentry.startTransaction("name", "op", TransactionOptions().app
 
 - Android only: `Sentry.getSpan()` returns the root span/transaction instead of the latest span ([#2855](https://github.com/getsentry/sentry-java/pull/2855))
 - Capture failed HTTP and GraphQL (Apollo) requests by default ([#2794](https://github.com/getsentry/sentry-java/pull/2794))
-    - This can increase your event consumption and may affect your quota, because we will report failed network requests as Sentry events by default, if you're using the `sentry-android-okhttp` or `sentry-apollo-3` integrations. You can customize what errors you want/don't want to have reported for [OkHttp](https://docs.sentry.io/platforms/android/integrations/okhttp#http-client-errors) and [Apollo3](https://docs.sentry.io/platforms/android/integrations/apollo3#graphql-client-errors) respectively.
+  - This can increase your event consumption and may affect your quota, because we will report failed network requests as Sentry events by default, if you're using the `sentry-android-okhttp` or `sentry-apollo-3` integrations. You can customize what errors you want/don't want to have reported for [OkHttp](https://docs.sentry.io/platforms/android/integrations/okhttp#http-client-errors) and [Apollo3](https://docs.sentry.io/platforms/android/integrations/apollo3#graphql-client-errors) respectively.
 - Measure AppStart time till First Draw instead of `onResume` ([#2851](https://github.com/getsentry/sentry-java/pull/2851))
 - Automatic user interaction tracking: every click now starts a new automatic transaction ([#2891](https://github.com/getsentry/sentry-java/pull/2891))
-    - Previously performing a click on the same UI widget twice would keep the existing transaction running, the new behavior now better aligns with other SDKs
+  - Previously performing a click on the same UI widget twice would keep the existing transaction running, the new behavior now better aligns with other SDKs
 - Add deadline timeout for automatic transactions ([#2865](https://github.com/getsentry/sentry-java/pull/2865))
-    - This affects all automatically generated transactions on Android (UI, clicks), the default timeout is 30s, meaning the automatic transaction will be force-finished with status `deadline_exceeded` when reaching the deadline 
+  - This affects all automatically generated transactions on Android (UI, clicks), the default timeout is 30s, meaning the automatic transaction will be force-finished with status `deadline_exceeded` when reaching the deadline
 - Set ip_address to {{auto}} by default, even if sendDefaultPII is disabled ([#2860](https://github.com/getsentry/sentry-java/pull/2860))
-    - Instead use the "Prevent Storing of IP Addresses" option in the "Security & Privacy" project settings on sentry.io
+  - Instead use the "Prevent Storing of IP Addresses" option in the "Security & Privacy" project settings on sentry.io
 - Raw logback message and parameters are now guarded by `sendDefaultPii` if an `encoder` has been configured ([#2976](https://github.com/getsentry/sentry-java/pull/2976))
 - The `maxSpans` setting (defaults to 1000) is enforced for nested child spans which means a single transaction can have `maxSpans` number of children (nested or not) at most ([#3065](https://github.com/getsentry/sentry-java/pull/3065))
 - The `ScopeCallback` in `withScope` is now always executed ([#3066](https://github.com/getsentry/sentry-java/pull/3066))
@@ -2405,8 +2416,8 @@ val transaction = Sentry.startTransaction("name", "op", TransactionOptions().app
 ### Features
 
 - Observe network state to upload any unsent envelopes ([#2910](https://github.com/getsentry/sentry-java/pull/2910))
-    - Android: it works out-of-the-box as part of the default `SendCachedEnvelopeIntegration`
-    - JVM: you'd have to install `SendCachedEnvelopeFireAndForgetIntegration` as mentioned in https://docs.sentry.io/platforms/java/configuration/#configuring-offline-caching and provide your own implementation of `IConnectionStatusProvider` via `SentryOptions`
+  - Android: it works out-of-the-box as part of the default `SendCachedEnvelopeIntegration`
+  - JVM: you'd have to install `SendCachedEnvelopeFireAndForgetIntegration` as mentioned in https://docs.sentry.io/platforms/java/configuration/#configuring-offline-caching and provide your own implementation of `IConnectionStatusProvider` via `SentryOptions`
 - Add `sentry-okhttp` module to support instrumenting OkHttp in non-Android projects ([#3005](https://github.com/getsentry/sentry-java/pull/3005))
 - Do not filter out Sentry SDK frames in case of uncaught exceptions ([#3021](https://github.com/getsentry/sentry-java/pull/3021))
 - Do not try to send and drop cached envelopes when rate-limiting is active ([#2937](https://github.com/getsentry/sentry-java/pull/2937))
@@ -2414,16 +2425,16 @@ val transaction = Sentry.startTransaction("name", "op", TransactionOptions().app
 ### Fixes
 
 - Use `getMyMemoryState()` instead of `getRunningAppProcesses()` to retrieve process importance ([#3004](https://github.com/getsentry/sentry-java/pull/3004))
-    - This should prevent some app stores from flagging apps as violating their privacy
+  - This should prevent some app stores from flagging apps as violating their privacy
 - Reduce flush timeout to 4s on Android to avoid ANRs ([#2858](https://github.com/getsentry/sentry-java/pull/2858))
 - Reduce timeout of AsyncHttpTransport to avoid ANR ([#2879](https://github.com/getsentry/sentry-java/pull/2879))
 - Do not overwrite UI transaction status if set by the user ([#2852](https://github.com/getsentry/sentry-java/pull/2852))
 - Capture unfinished transaction on Scope with status `aborted` in case a crash happens ([#2938](https://github.com/getsentry/sentry-java/pull/2938))
-    - This will fix the link between transactions and corresponding crashes, you'll be able to see them in a single trace
+  - This will fix the link between transactions and corresponding crashes, you'll be able to see them in a single trace
 - Fix Coroutine Context Propagation using CopyableThreadContextElement ([#2838](https://github.com/getsentry/sentry-java/pull/2838))
 - Fix don't overwrite the span status of unfinished spans ([#2859](https://github.com/getsentry/sentry-java/pull/2859))
 - Migrate from `default` interface methods to proper implementations in each interface implementor ([#2847](https://github.com/getsentry/sentry-java/pull/2847))
-    - This prevents issues when using the SDK on older AGP versions (< 4.x.x)
+  - This prevents issues when using the SDK on older AGP versions (< 4.x.x)
 - Reduce main thread work on init ([#3036](https://github.com/getsentry/sentry-java/pull/3036))
 - Move Integrations registration to background on init ([#3043](https://github.com/getsentry/sentry-java/pull/3043))
 - Fix `SentryOkHttpInterceptor.BeforeSpanCallback` was not finishing span when it was dropped ([#2958](https://github.com/getsentry/sentry-java/pull/2958))
@@ -2442,7 +2453,7 @@ val transaction = Sentry.startTransaction("name", "op", TransactionOptions().app
 
 ### Fixes
 
--  Fix SIGSEV, SIGABRT and SIGBUS crashes happening after/around the August Google Play System update, see [#2955](https://github.com/getsentry/sentry-java/issues/2955) for more details (fix provided by Native SDK bump)
+- Fix SIGSEV, SIGABRT and SIGBUS crashes happening after/around the August Google Play System update, see [#2955](https://github.com/getsentry/sentry-java/issues/2955) for more details (fix provided by Native SDK bump)
 - Ensure DSN uses http/https protocol ([#3044](https://github.com/getsentry/sentry-java/pull/3044))
 
 ### Dependencies
@@ -2455,7 +2466,7 @@ val transaction = Sentry.startTransaction("name", "op", TransactionOptions().app
 
 ### Fixes
 
--  Fix SIGSEV, SIGABRT and SIGBUS crashes happening after/around the August Google Play System update, see [#2955](https://github.com/getsentry/sentry-java/issues/2955) for more details (fix provided by Native SDK bump)
+- Fix SIGSEV, SIGABRT and SIGBUS crashes happening after/around the August Google Play System update, see [#2955](https://github.com/getsentry/sentry-java/issues/2955) for more details (fix provided by Native SDK bump)
 
 ### Dependencies
 
@@ -2567,15 +2578,15 @@ val transaction = Sentry.startTransaction("name", "op", TransactionOptions().app
 - Add HTTP response code to Spring WebFlux transactions ([#2870](https://github.com/getsentry/sentry-java/pull/2870))
 - Add `sampled` to Dynamic Sampling Context ([#2869](https://github.com/getsentry/sentry-java/pull/2869))
 - Improve server side GraphQL support for spring-graphql and Nextflix DGS ([#2856](https://github.com/getsentry/sentry-java/pull/2856))
-    - If you have already been using `SentryDataFetcherExceptionHandler` that still works but has been deprecated. Please use `SentryGenericDataFetcherExceptionHandler` combined with `SentryInstrumentation` instead for better error reporting.
-    - More exceptions and errors caught and reported to Sentry by also looking at the `ExecutionResult` (more specifically its `errors`)
-        - You may want to filter out certain errors, please see [docs on filtering](https://docs.sentry.io/platforms/java/configuration/filtering/)
-    - More details for Sentry events: query, variables and response (where possible)
-    - Breadcrumbs for operation (query, mutation, subscription), data fetchers and data loaders (Spring only)
-    - Better hub propagation by using `GraphQLContext`
+  - If you have already been using `SentryDataFetcherExceptionHandler` that still works but has been deprecated. Please use `SentryGenericDataFetcherExceptionHandler` combined with `SentryInstrumentation` instead for better error reporting.
+  - More exceptions and errors caught and reported to Sentry by also looking at the `ExecutionResult` (more specifically its `errors`)
+    - You may want to filter out certain errors, please see [docs on filtering](https://docs.sentry.io/platforms/java/configuration/filtering/)
+  - More details for Sentry events: query, variables and response (where possible)
+  - Breadcrumbs for operation (query, mutation, subscription), data fetchers and data loaders (Spring only)
+  - Better hub propagation by using `GraphQLContext`
 - Add autoconfigure modules for Spring Boot called `sentry-spring-boot` and `sentry-spring-boot-jakarta` ([#2880](https://github.com/getsentry/sentry-java/pull/2880))
   - The autoconfigure modules `sentry-spring-boot` and `sentry-spring-boot-jakarta` have a `compileOnly` dependency on `spring-boot-starter` which is needed for our auto installation in [sentry-android-gradle-plugin](https://github.com/getsentry/sentry-android-gradle-plugin)
-  - The starter modules  `sentry-spring-boot-starter` and `sentry-spring-boot-starter-jakarta` now bring `spring-boot-starter` as a dependency
+  - The starter modules `sentry-spring-boot-starter` and `sentry-spring-boot-starter-jakarta` now bring `spring-boot-starter` as a dependency
 - You can now disable Sentry by setting the `enabled` option to `false` ([#2840](https://github.com/getsentry/sentry-java/pull/2840))
 
 ### Fixes
@@ -2598,6 +2609,7 @@ val transaction = Sentry.startTransaction("name", "op", TransactionOptions().app
 ## 6.26.0
 
 ### Features
+
 - (Internal) Extend APIs for hybrid SDKs ([#2814](https://github.com/getsentry/sentry-java/pull/2814), [#2846](https://github.com/getsentry/sentry-java/pull/2846))
 
 ### Fixes
@@ -2658,13 +2670,13 @@ val transaction = Sentry.startTransaction("name", "op", TransactionOptions().app
 - Add debouncing mechanism and before-capture callbacks for screenshots and view hierarchies ([#2773](https://github.com/getsentry/sentry-java/pull/2773))
 - Improve ANRv2 implementation ([#2792](https://github.com/getsentry/sentry-java/pull/2792))
   - Add a proguard rule to keep `ApplicationNotResponding` class from obfuscation
-  - Add a new option `setReportHistoricalAnrs`; when enabled, it will report all of the ANRs from the [getHistoricalExitReasons](https://developer.android.com/reference/android/app/ActivityManager?hl=en#getHistoricalProcessExitReasons(java.lang.String,%20int,%20int)) list. 
-  By default, the SDK only reports and enriches the latest ANR and only this one counts towards ANR rate. 
-  Worth noting that this option is mainly useful when updating the SDK to the version where ANRv2 has been introduced, to report all ANRs happened prior to the SDK update. After that, the SDK will always pick up the latest ANR from the historical exit reasons list on next app restart, so there should be no historical ANRs to report.
-  These ANRs are reported with the `HistoricalAppExitInfo` mechanism.
-  - Add a new option `setAttachAnrThreadDump` to send ANR thread dump from the system as an attachment. 
-  This is only useful as additional information, because the SDK attempts to parse the thread dump into proper threads with stacktraces by default.
-  - If [ApplicationExitInfo#getTraceInputStream](https://developer.android.com/reference/android/app/ApplicationExitInfo#getTraceInputStream()) returns null, the SDK no longer reports an ANR event, as these events are not very useful without it.
+  - Add a new option `setReportHistoricalAnrs`; when enabled, it will report all of the ANRs from the [getHistoricalExitReasons](<https://developer.android.com/reference/android/app/ActivityManager?hl=en#getHistoricalProcessExitReasons(java.lang.String,%20int,%20int)>) list.
+    By default, the SDK only reports and enriches the latest ANR and only this one counts towards ANR rate.
+    Worth noting that this option is mainly useful when updating the SDK to the version where ANRv2 has been introduced, to report all ANRs happened prior to the SDK update. After that, the SDK will always pick up the latest ANR from the historical exit reasons list on next app restart, so there should be no historical ANRs to report.
+    These ANRs are reported with the `HistoricalAppExitInfo` mechanism.
+  - Add a new option `setAttachAnrThreadDump` to send ANR thread dump from the system as an attachment.
+    This is only useful as additional information, because the SDK attempts to parse the thread dump into proper threads with stacktraces by default.
+  - If [ApplicationExitInfo#getTraceInputStream](<https://developer.android.com/reference/android/app/ApplicationExitInfo#getTraceInputStream()>) returns null, the SDK no longer reports an ANR event, as these events are not very useful without it.
   - Enhance regex patterns for native stackframes
 
 ## 6.23.0
@@ -2680,7 +2692,7 @@ import io.sentry.apollo3.sentryTracing
 
 val apolloClient = ApolloClient.Builder()
     .serverUrl("https://example.com/graphql")
-    .sentryTracing(captureFailedRequests = true)    
+    .sentryTracing(captureFailedRequests = true)
     .build()
 ```
 
@@ -2711,9 +2723,9 @@ val apolloClient = ApolloClient.Builder()
 ### Features
 
 - Introduce new `sentry-android-sqlite` integration ([#2722](https://github.com/getsentry/sentry-java/pull/2722))
-    - This integration replaces the old `androidx.sqlite` database instrumentation in the Sentry Android Gradle plugin
-    - A new capability to manually instrument your `androidx.sqlite` databases. 
-      - You can wrap your custom `SupportSQLiteOpenHelper` instance into `SentrySupportSQLiteOpenHelper(myHelper)` if you're not using the Sentry Android Gradle plugin and still benefit from performance auto-instrumentation.
+  - This integration replaces the old `androidx.sqlite` database instrumentation in the Sentry Android Gradle plugin
+  - A new capability to manually instrument your `androidx.sqlite` databases.
+    - You can wrap your custom `SupportSQLiteOpenHelper` instance into `SentrySupportSQLiteOpenHelper(myHelper)` if you're not using the Sentry Android Gradle plugin and still benefit from performance auto-instrumentation.
 - Add SentryWrapper for Callable and Supplier Interface ([#2720](https://github.com/getsentry/sentry-java/pull/2720))
 - Load sentry-debug-meta.properties ([#2734](https://github.com/getsentry/sentry-java/pull/2734))
   - This enables source context for Java
@@ -2736,15 +2748,15 @@ val apolloClient = ApolloClient.Builder()
     - [View Hierarchy](https://docs.sentry.io/platforms/android/enriching-events/viewhierarchy/) support for Jetpack Compose screens
     - Automatic breadcrumbs for [user interactions](https://docs.sentry.io/platforms/android/performance/instrumentation/automatic-instrumentation/#user-interaction-instrumentation)
 - More granular http requests instrumentation with a new SentryOkHttpEventListener ([#2659](https://github.com/getsentry/sentry-java/pull/2659))
-    - Create spans for time spent on:
-        - Proxy selection
-        - DNS resolution
-        - HTTPS setup
-        - Connection
-        - Requesting headers
-        - Receiving response
-    - You can attach the event listener to your OkHttpClient through `client.eventListener(new SentryOkHttpEventListener()).addInterceptor(new SentryOkHttpInterceptor()).build();`
-    - In case you already have an event listener you can use the SentryOkHttpEventListener as well through `client.eventListener(new SentryOkHttpEventListener(myListener)).addInterceptor(new SentryOkHttpInterceptor()).build();`
+  - Create spans for time spent on:
+    - Proxy selection
+    - DNS resolution
+    - HTTPS setup
+    - Connection
+    - Requesting headers
+    - Receiving response
+  - You can attach the event listener to your OkHttpClient through `client.eventListener(new SentryOkHttpEventListener()).addInterceptor(new SentryOkHttpInterceptor()).build();`
+  - In case you already have an event listener you can use the SentryOkHttpEventListener as well through `client.eventListener(new SentryOkHttpEventListener(myListener)).addInterceptor(new SentryOkHttpInterceptor()).build();`
 - Add a new option to disable `RootChecker` ([#2735](https://github.com/getsentry/sentry-java/pull/2735))
 
 ### Fixes
@@ -2765,16 +2777,16 @@ val apolloClient = ApolloClient.Builder()
 
 - Add Screenshot and ViewHierarchy to integrations list ([#2698](https://github.com/getsentry/sentry-java/pull/2698))
 - New ANR detection based on [ApplicationExitInfo API](https://developer.android.com/reference/android/app/ApplicationExitInfo) ([#2697](https://github.com/getsentry/sentry-java/pull/2697))
-    - This implementation completely replaces the old one (based on a watchdog) on devices running Android 11 and above:
-      - New implementation provides more precise ANR events/ANR rate detection as well as system thread dump information. The new implementation reports ANRs exactly as Google Play Console, without producing false positives or missing important background ANR events.
-      - New implementation reports ANR events with a new mechanism `mechanism:AppExitInfo`.
-      - However, despite producing many false positives, the old implementation is capable of better enriching ANR errors (which is not available with the new implementation), for example:
-        - Capturing screenshots at the time of ANR event;
-        - Capturing transactions and profiling data corresponding to the ANR event;
-        - Auxiliary information (such as current memory load) at the time of ANR event.
-      - If you would like us to provide support for the old approach working alongside the new one on Android 11 and above (e.g. for raising events for slow code on main thread), consider upvoting [this issue](https://github.com/getsentry/sentry-java/issues/2693).
-    - The old watchdog implementation will continue working for older API versions (Android < 11):
-        - The old implementation reports ANR events with the existing mechanism `mechanism:ANR`.
+  - This implementation completely replaces the old one (based on a watchdog) on devices running Android 11 and above:
+    - New implementation provides more precise ANR events/ANR rate detection as well as system thread dump information. The new implementation reports ANRs exactly as Google Play Console, without producing false positives or missing important background ANR events.
+    - New implementation reports ANR events with a new mechanism `mechanism:AppExitInfo`.
+    - However, despite producing many false positives, the old implementation is capable of better enriching ANR errors (which is not available with the new implementation), for example:
+      - Capturing screenshots at the time of ANR event;
+      - Capturing transactions and profiling data corresponding to the ANR event;
+      - Auxiliary information (such as current memory load) at the time of ANR event.
+    - If you would like us to provide support for the old approach working alongside the new one on Android 11 and above (e.g. for raising events for slow code on main thread), consider upvoting [this issue](https://github.com/getsentry/sentry-java/issues/2693).
+  - The old watchdog implementation will continue working for older API versions (Android < 11):
+    - The old implementation reports ANR events with the existing mechanism `mechanism:ANR`.
 - Open up `TransactionOptions`, `ITransaction` and `IHub` methods allowing consumers modify start/end timestamp of transactions and spans ([#2701](https://github.com/getsentry/sentry-java/pull/2701))
 - Send source bundle IDs to Sentry to enable source context ([#2663](https://github.com/getsentry/sentry-java/pull/2663))
   - For more information on how to enable source context, please refer to [#633](https://github.com/getsentry/sentry-java/issues/633#issuecomment-1465599120)
@@ -2809,7 +2821,7 @@ val apolloClient = ApolloClient.Builder()
 
 - Attach Trace Context when an ANR is detected (ANRv1) ([#2583](https://github.com/getsentry/sentry-java/pull/2583))
 - Make log4j2 integration compatible with log4j 3.0 ([#2634](https://github.com/getsentry/sentry-java/pull/2634))
-    - Instead of relying on package scanning, we now use an annotation processor to generate `Log4j2Plugins.dat`
+  - Instead of relying on package scanning, we now use an annotation processor to generate `Log4j2Plugins.dat`
 - Create `User` and `Breadcrumb` from map ([#2614](https://github.com/getsentry/sentry-java/pull/2614))
 - Add `sent_at` to envelope header item ([#2638](https://github.com/getsentry/sentry-java/pull/2638))
 
@@ -2822,12 +2834,13 @@ val apolloClient = ApolloClient.Builder()
 - Fix aar artifacts publishing for Maven ([#2641](https://github.com/getsentry/sentry-java/pull/2641))
 
 ### Dependencies
+
 - Bump Kotlin compile version from v1.6.10 to 1.8.0 ([#2563](https://github.com/getsentry/sentry-java/pull/2563))
 - Bump Compose compile version from v1.1.1 to v1.3.0 ([#2563](https://github.com/getsentry/sentry-java/pull/2563))
 - Bump AGP version from v7.3.0 to v7.4.2 ([#2574](https://github.com/getsentry/sentry-java/pull/2574))
 - Bump Gradle from v7.6.0 to v8.0.2 ([#2563](https://github.com/getsentry/sentry-java/pull/2563))
-    - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v802)
-    - [diff](https://github.com/gradle/gradle/compare/v7.6.0...v8.0.2)
+  - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v802)
+  - [diff](https://github.com/gradle/gradle/compare/v7.6.0...v8.0.2)
 - Bump Gradle from v8.0.2 to v8.1.0 ([#2650](https://github.com/getsentry/sentry-java/pull/2650))
   - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v810)
   - [diff](https://github.com/gradle/gradle/compare/v8.0.2...v8.1.0)
@@ -2836,7 +2849,7 @@ val apolloClient = ApolloClient.Builder()
 
 ### Features
 
-- Add `name` and `geo` to `User` ([#2556](https://github.com/getsentry/sentry-java/pull/2556)) 
+- Add `name` and `geo` to `User` ([#2556](https://github.com/getsentry/sentry-java/pull/2556))
 - Add breadcrumbs on network changes ([#2608](https://github.com/getsentry/sentry-java/pull/2608))
 - Add time-to-initial-display and time-to-full-display measurements to Activity transactions ([#2611](https://github.com/getsentry/sentry-java/pull/2611))
 - Read integration list written by sentry gradle plugin from manifest ([#2598](https://github.com/getsentry/sentry-java/pull/2598))
@@ -2874,7 +2887,7 @@ val apolloClient = ApolloClient.Builder()
 - Fix timestamps of slow and frozen frames for profiles ([#2584](https://github.com/getsentry/sentry-java/pull/2584))
 - Deprecate reportFullDisplayed in favor of reportFullyDisplayed ([#2585](https://github.com/getsentry/sentry-java/pull/2585))
 - Add mechanism for logging integrations and update spring mechanism types ([#2595](https://github.com/getsentry/sentry-java/pull/2595))
-	- NOTE: If you're using these mechanism types (`HandlerExceptionResolver`, `SentryWebExceptionHandler`) in your dashboards please update them to use the new types.
+  - NOTE: If you're using these mechanism types (`HandlerExceptionResolver`, `SentryWebExceptionHandler`) in your dashboards please update them to use the new types.
 - Filter out session cookies sent by Spring and Spring Boot integrations ([#2593](https://github.com/getsentry/sentry-java/pull/2593))
   - We filter out some common cookies like JSESSIONID
   - We also read the value from `server.servlet.session.cookie.name` and filter it out
@@ -2899,9 +2912,9 @@ val apolloClient = ApolloClient.Builder()
 
 - Adjust time-to-full-display span if reportFullDisplayed is called too early ([#2550](https://github.com/getsentry/sentry-java/pull/2550))
 - Add `enableTracing` option ([#2530](https://github.com/getsentry/sentry-java/pull/2530))
-    - This change is backwards compatible. The default is `null` meaning existing behaviour remains unchanged (setting either `tracesSampleRate` or `tracesSampler` enables performance).
-    - If set to `true`, performance is enabled, even if no `tracesSampleRate` or `tracesSampler` have been configured.
-    - If set to `false` performance is disabled, regardless of `tracesSampleRate` and `tracesSampler` options.
+  - This change is backwards compatible. The default is `null` meaning existing behaviour remains unchanged (setting either `tracesSampleRate` or `tracesSampler` enables performance).
+  - If set to `true`, performance is enabled, even if no `tracesSampleRate` or `tracesSampler` have been configured.
+  - If set to `false` performance is disabled, regardless of `tracesSampleRate` and `tracesSampler` options.
 - Detect dependencies by listing MANIFEST.MF files at runtime ([#2538](https://github.com/getsentry/sentry-java/pull/2538))
 - Report integrations in use, report packages in use more consistently ([#2179](https://github.com/getsentry/sentry-java/pull/2179))
 - Implement `ThreadLocalAccessor` for propagating Sentry hub with reactor / WebFlux ([#2570](https://github.com/getsentry/sentry-java/pull/2570))
@@ -2928,7 +2941,7 @@ val apolloClient = ApolloClient.Builder()
 ### Features
 
 - Add time-to-full-display span to Activity auto-instrumentation ([#2432](https://github.com/getsentry/sentry-java/pull/2432))
-- Add `main` flag to threads and `in_foreground` flag for app contexts  ([#2516](https://github.com/getsentry/sentry-java/pull/2516))
+- Add `main` flag to threads and `in_foreground` flag for app contexts ([#2516](https://github.com/getsentry/sentry-java/pull/2516))
 
 ### Fixes
 
@@ -3164,7 +3177,7 @@ val apolloClient = ApolloClient.Builder()
 
 ### Features
 
-- Server-Side Dynamic Sampling Context support  ([#2226](https://github.com/getsentry/sentry-java/pull/2226))
+- Server-Side Dynamic Sampling Context support ([#2226](https://github.com/getsentry/sentry-java/pull/2226))
 
 ## 6.4.4
 
@@ -3225,7 +3238,6 @@ val apolloClient = ApolloClient.Builder()
 - `attach-screenshot` set on Manual init. didn't work ([#2186](https://github.com/getsentry/sentry-java/pull/2186))
 - Remove extra space from `spring.factories` causing issues in old versions of Spring Boot ([#2181](https://github.com/getsentry/sentry-java/pull/2181))
 
-
 ### Features
 
 - Bump Native SDK to v0.4.18 ([#2154](https://github.com/getsentry/sentry-java/pull/2154))
@@ -3260,6 +3272,7 @@ val apolloClient = ApolloClient.Builder()
 - Add sample rate to baggage as well as trace in envelope header and flatten user ([#2135](https://github.com/getsentry/sentry-java/pull/2135))
 
 Breaking Changes:
+
 - The boolean parameter `samplingDecision` in the `TransactionContext` constructor has been replaced with a `TracesSamplingDecision` object. Feel free to ignore the `@ApiStatus.Internal` in this case.
 
 ## 6.1.4
@@ -3323,19 +3336,19 @@ Breaking Changes:
 - Add Android profiling traces ([#1897](https://github.com/getsentry/sentry-java/pull/1897)) ([#1959](https://github.com/getsentry/sentry-java/pull/1959)) and its tests ([#1949](https://github.com/getsentry/sentry-java/pull/1949))
 - Enable enableScopeSync by default for Android ([#1928](https://github.com/getsentry/sentry-java/pull/1928))
 - Feat: Vendor JSON ([#1554](https://github.com/getsentry/sentry-java/pull/1554))
-    - Introduce `JsonSerializable` and `JsonDeserializer` interfaces for manual json
-      serialization/deserialization.
-    - Introduce `JsonUnknwon` interface to preserve unknown properties when deserializing/serializing
-      SDK classes.
-    - When passing custom objects, for example in `Contexts`, these are supported for serialization:
-        - `JsonSerializable`
-        - `Map`, `Collection`, `Array`, `String` and all primitive types.
-        - Objects with the help of refection.
-            - `Map`, `Collection`, `Array`, `String` and all primitive types.
-            - Call `toString()` on objects that have a cyclic reference to a ancestor object.
-            - Call `toString()` where object graphs exceed max depth.
-    - Remove `gson` dependency.
-    - Remove `IUnknownPropertiesConsumer`
+  - Introduce `JsonSerializable` and `JsonDeserializer` interfaces for manual json
+    serialization/deserialization.
+  - Introduce `JsonUnknwon` interface to preserve unknown properties when deserializing/serializing
+    SDK classes.
+  - When passing custom objects, for example in `Contexts`, these are supported for serialization:
+    - `JsonSerializable`
+    - `Map`, `Collection`, `Array`, `String` and all primitive types.
+    - Objects with the help of refection.
+      - `Map`, `Collection`, `Array`, `String` and all primitive types.
+      - Call `toString()` on objects that have a cyclic reference to a ancestor object.
+      - Call `toString()` where object graphs exceed max depth.
+  - Remove `gson` dependency.
+  - Remove `IUnknownPropertiesConsumer`
 - Pass MDC tags as Sentry tags ([#1954](https://github.com/getsentry/sentry-java/pull/1954))
 
 ### Fixes
@@ -3377,7 +3390,7 @@ Breaking Changes:
 
 ### Fixes
 
-* Change order of event filtering mechanisms and only send session update for dropped events if session state changed (#2028)
+- Change order of event filtering mechanisms and only send session update for dropped events if session state changed (#2028)
 
 ## 5.7.3
 
@@ -3771,7 +3784,6 @@ Thank you:
 
 ### Fixes
 
-
 - Ref: Deprecate SentryBaseEvent#getOriginThrowable and add SentryBaseEvent#getThrowableMechanism ([#1502](https://github.com/getsentry/sentry-java/pull/1502))
 - Graceful Shutdown flushes event instead of Closing SDK ([#1500](https://github.com/getsentry/sentry-java/pull/1500))
 - Do not append threads that come from the EnvelopeFileObserver ([#1501](https://github.com/getsentry/sentry-java/pull/1501))
@@ -3930,6 +3942,7 @@ Breaking Changes:
 - SentryTransaction#finish should not clear another transaction from the scope ([#1278](https://github.com/getsentry/sentry-java/pull/1278))
 
 Breaking Changes:
+
 - Enchancement: SentryExceptionResolver should not send handled errors by default ([#1248](https://github.com/getsentry/sentry-java/pull/1248)).
 - Ref: Simplify RestTemplate instrumentation ([#1246](https://github.com/getsentry/sentry-java/pull/1246))
 - Enchancement: Add overloads for startTransaction taking op and description ([#1244](https://github.com/getsentry/sentry-java/pull/1244))
@@ -4083,7 +4096,7 @@ This release brings the Sentry Performance feature to Java SDK, Spring, Spring B
 - Set current thread only if theres no exceptions ([#1064](https://github.com/getsentry/sentry-java/pull/1064))
 - Append DebugImage list if event already has it ([#1092](https://github.com/getsentry/sentry-java/pull/1092))
 - Sort breadcrumbs by Date if there are breadcrumbs already in the event ([#1094](https://github.com/getsentry/sentry-java/pull/1094))
-- Free Local Refs manually due to Android local ref. count limits  ([#1179](https://github.com/getsentry/sentry-java/pull/1179))
+- Free Local Refs manually due to Android local ref. count limits ([#1179](https://github.com/getsentry/sentry-java/pull/1179))
 
 ## 3.2.0
 
@@ -4204,6 +4217,7 @@ Packages were released on [`bintray sentry-java`](https://dl.bintray.com/getsent
 ## Where is the Java 1.7 code base?
 
 The previous Java releases, are all available in this repository through the tagged releases.
+
 ## 3.0.0-beta.1
 
 ## What’s Changed
@@ -4243,7 +4257,7 @@ TBD
 Packages were released on [bintray](https://dl.bintray.com/getsentry/maven/io/sentry/)
 
 > Note: This release marks the unification of the Java and Android Sentry codebases based on the core of the Android SDK (version 2.x).
-Previous releases for the Android SDK (version 2.x) can be found on the now archived: https://github.com/getsentry/sentry-android/
+> Previous releases for the Android SDK (version 2.x) can be found on the now archived: https://github.com/getsentry/sentry-android/
 
 ## 3.0.0-alpha.1
 
@@ -4251,7 +4265,6 @@ Previous releases for the Android SDK (version 2.x) can be found on the now arch
 
 ### Fixes
 
-
 ## New releases will happen on a different repository:
 
 https://github.com/getsentry/sentry-java
@@ -4262,7 +4275,6 @@ https://github.com/getsentry/sentry-java
 
 ### Fixes
 
-
 - feat: enable release health by default
 
 Packages were released on [`bintray`](https://dl.bintray.com/getsentry/sentry-android/io/sentry/sentry-android/), [`jcenter`](https://jcenter.bintray.com/io/sentry/sentry-android/) and [`mavenCentral`](https://repo.maven.apache.org/maven2/io/sentry/sentry-android/)
@@ -4346,15 +4358,15 @@ We'd love to get feedback.
 
 - feat: timber integration ([#464](https://github.com/getsentry/sentry-android/pull/464)) @marandaneto
 
-1) To add integrations it requires a [manual initialization](https://docs.sentry.io/platforms/android/#manual-initialization) of the Android SDK.
+1. To add integrations it requires a [manual initialization](https://docs.sentry.io/platforms/android/#manual-initialization) of the Android SDK.
 
-2) Add the `sentry-android-timber` dependency:
+2. Add the `sentry-android-timber` dependency:
 
 ```groovy
 implementation 'io.sentry:sentry-android-timber:{version}' // version >= 2.2.0
 ```
 
-3) Initialize and add the `SentryTimberIntegration`:
+3. Initialize and add the `SentryTimberIntegration`:
 
 ```java
 SentryAndroid.init(this, options -> {
@@ -4368,7 +4380,7 @@ SentryAndroid.init(this, options -> {
 });
 ```
 
-4) Use the Timber integration:
+4. Use the Timber integration:
 
 ```java
 try {
@@ -4657,8 +4669,8 @@ New features not offered by (1.7.x):
   - Captures crashes caused by native code
   - Access to the [`sentry-native` SDK](https://github.com/getsentry/sentry-native/) API by your native (C/C++/Rust code/..).
 - Automatic init (just add your `DSN` to the manifest)
-   - Proguard rules are added automatically
-   - Permission (Internet) is added automatically
+  - Proguard rules are added automatically
+  - Permission (Internet) is added automatically
 - Uncaught Exceptions might be captured even before the app restarts
 - Sentry's Unified API.
 - More context/device information
@@ -4719,7 +4731,6 @@ Release of Sentry's new SDK for Android.
 
 ### Fixes
 
-
 - Update ndk for new sentry-native version ([#235](https://github.com/getsentry/sentry-android/pull/235)) @Swatinem @marandaneto
 - Make integrations public ([#256](https://github.com/getsentry/sentry-android/pull/256)) @marandaneto
 - Bump build-tools ([#255](https://github.com/getsentry/sentry-android/pull/255)) @marandaneto
@@ -4757,7 +4768,6 @@ Release of Sentry's new SDK for Android.
 
 ### Fixes
 
-
 - Honor RetryAfter ([#236](https://github.com/getsentry/sentry-android/pull/236)) @marandaneto
 - Add tests for SentryValues ([#238](https://github.com/getsentry/sentry-android/pull/238)) @philipphofmann
 - Do not set frames if there's none ([#234](https://github.com/getsentry/sentry-android/pull/234)) @marandaneto
@@ -4858,7 +4868,7 @@ Third release of Sentry's new SDK for Android.
 
 ### Fixes
 
--  Fixed release for jcenter and bintray
+- Fixed release for jcenter and bintray
 
 Packages were released on [`bintray`](https://dl.bintray.com/getsentry/sentry-android/io/sentry/), [`jcenter`](https://jcenter.bintray.com/io/sentry/sentry-android/)
 
@@ -4888,8 +4898,8 @@ New features not offered by our current (1.7.x), stable SDK are:
   - Captures crashes caused by native code
   - Access to the [`sentry-native` SDK](https://github.com/getsentry/sentry-native/) API by your native (C/C++/Rust code/..).
 - Automatic init (just add your `DSN` to the manifest)
-   - Proguard rules are added automatically
-   - Permission (Internet) is added automatically
+  - Proguard rules are added automatically
+  - Permission (Internet) is added automatically
 - Uncaught Exceptions might be captured even before the app restarts
 - Unified API which include scopes etc.
 - More context/device information
diff --git a/sentry-android-ndk/api/sentry-android-ndk.api b/sentry-android-ndk/api/sentry-android-ndk.api
index 44c153a71fe..a7c5571d0bb 100644
--- a/sentry-android-ndk/api/sentry-android-ndk.api
+++ b/sentry-android-ndk/api/sentry-android-ndk.api
@@ -15,7 +15,9 @@ public final class io/sentry/android/ndk/DebugImagesLoader : io/sentry/android/c
 
 public final class io/sentry/android/ndk/NdkScopeObserver : io/sentry/ScopeObserverAdapter {
 	public fun <init> (Lio/sentry/SentryOptions;)V
+	public fun addAttachment (Lio/sentry/Attachment;)V
 	public fun addBreadcrumb (Lio/sentry/Breadcrumb;)V
+	public fun clearAttachments ()V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun setExtra (Ljava/lang/String;Ljava/lang/String;)V
diff --git a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/NdkScopeObserver.java b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/NdkScopeObserver.java
index 023ce965f51..a1474bb69c8 100644
--- a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/NdkScopeObserver.java
+++ b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/NdkScopeObserver.java
@@ -1,5 +1,6 @@
 package io.sentry.android.ndk;
 
+import io.sentry.Attachment;
 import io.sentry.Breadcrumb;
 import io.sentry.DateUtils;
 import io.sentry.IScope;
@@ -145,4 +146,41 @@ public void setTrace(@Nullable SpanContext spanContext, @NotNull IScope scope) {
       options.getLogger().log(SentryLevel.ERROR, e, "Scope sync setTrace failed.");
     }
   }
+
+  @Override
+  public void addAttachment(final @NotNull Attachment attachment) {
+    final String pathname = attachment.getPathname();
+    if (pathname != null) {
+      try {
+        options.getExecutorService().submit(() -> nativeScope.addAttachment(pathname));
+      } catch (Throwable e) {
+        options.getLogger().log(SentryLevel.ERROR, e, "Scope sync addAttachment has an error.");
+      }
+      return;
+    }
+
+    final byte[] bytes = attachment.getBytes();
+    if (bytes != null) {
+      final String filename = attachment.getFilename();
+      try {
+        options.getExecutorService().submit(() -> nativeScope.addAttachmentBytes(bytes, filename));
+      } catch (Throwable e) {
+        options.getLogger().log(SentryLevel.ERROR, e, "Scope sync addAttachment has an error.");
+      }
+      return;
+    }
+
+    options
+        .getLogger()
+        .log(SentryLevel.DEBUG, "Scope sync addAttachment skips attachment without path or bytes.");
+  }
+
+  @Override
+  public void clearAttachments() {
+    try {
+      options.getExecutorService().submit(() -> nativeScope.clearAttachments());
+    } catch (Throwable e) {
+      options.getLogger().log(SentryLevel.ERROR, e, "Scope sync clearAttachments has an error.");
+    }
+  }
 }
diff --git a/sentry-android-ndk/src/test/java/io/sentry/android/ndk/NdkScopeObserverTest.kt b/sentry-android-ndk/src/test/java/io/sentry/android/ndk/NdkScopeObserverTest.kt
index 696bb69a8d5..a8b5318bfab 100644
--- a/sentry-android-ndk/src/test/java/io/sentry/android/ndk/NdkScopeObserverTest.kt
+++ b/sentry-android-ndk/src/test/java/io/sentry/android/ndk/NdkScopeObserverTest.kt
@@ -1,5 +1,6 @@
 package io.sentry.android.ndk
 
+import io.sentry.Attachment
 import io.sentry.Breadcrumb
 import io.sentry.DateUtils
 import io.sentry.JsonSerializer
@@ -153,4 +154,34 @@ class NdkScopeObserverTest {
     verify(fixture.nativeScope)
       .addBreadcrumb(anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull(), anyOrNull())
   }
+
+  @Test
+  fun `add file-path attachment syncs to native scope`() {
+    val sut = fixture.getSut()
+
+    val attachment = Attachment("/data/data/com.example/files/log.txt")
+    sut.addAttachment(attachment)
+
+    verify(fixture.nativeScope).addAttachment("/data/data/com.example/files/log.txt")
+  }
+
+  @Test
+  fun `add byte attachment syncs bytes to native scope`() {
+    val sut = fixture.getSut()
+
+    val bytes = byteArrayOf(1, 2, 3)
+    val attachment = Attachment(bytes, "data.bin")
+    sut.addAttachment(attachment)
+
+    verify(fixture.nativeScope).addAttachmentBytes(bytes, "data.bin")
+  }
+
+  @Test
+  fun `clear attachments forwards call to native scope`() {
+    val sut = fixture.getSut()
+
+    sut.clearAttachments()
+
+    verify(fixture.nativeScope).clearAttachments()
+  }
 }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index c748df38369..3962c3ef1e2 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -945,7 +945,9 @@ public abstract interface class io/sentry/IScope {
 }
 
 public abstract interface class io/sentry/IScopeObserver {
+	public abstract fun addAttachment (Lio/sentry/Attachment;)V
 	public abstract fun addBreadcrumb (Lio/sentry/Breadcrumb;)V
+	public abstract fun clearAttachments ()V
 	public abstract fun removeExtra (Ljava/lang/String;)V
 	public abstract fun removeTag (Ljava/lang/String;)V
 	public abstract fun setBreadcrumbs (Ljava/util/Collection;)V
@@ -2452,7 +2454,9 @@ public abstract interface class io/sentry/ScopeCallback {
 
 public abstract class io/sentry/ScopeObserverAdapter : io/sentry/IScopeObserver {
 	public fun <init> ()V
+	public fun addAttachment (Lio/sentry/Attachment;)V
 	public fun addBreadcrumb (Lio/sentry/Breadcrumb;)V
+	public fun clearAttachments ()V
 	public fun removeExtra (Ljava/lang/String;)V
 	public fun removeTag (Ljava/lang/String;)V
 	public fun setBreadcrumbs (Ljava/util/Collection;)V
diff --git a/sentry/src/main/java/io/sentry/IScopeObserver.java b/sentry/src/main/java/io/sentry/IScopeObserver.java
index a43ccf6b695..e1b9a785043 100644
--- a/sentry/src/main/java/io/sentry/IScopeObserver.java
+++ b/sentry/src/main/java/io/sentry/IScopeObserver.java
@@ -45,4 +45,8 @@ public interface IScopeObserver {
   void setTrace(@Nullable SpanContext spanContext, @NotNull IScope scope);
 
   void setReplayId(@NotNull SentryId replayId);
+
+  void addAttachment(@NotNull Attachment attachment);
+
+  void clearAttachments();
 }
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index 1aab545b80c..fa44e90a194 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -924,12 +924,20 @@ public List<Attachment> getAttachments() {
   @Override
   public void addAttachment(final @NotNull Attachment attachment) {
     attachments.add(attachment);
+
+    for (final IScopeObserver observer : options.getScopeObservers()) {
+      observer.addAttachment(attachment);
+    }
   }
 
   /** Clear all attachments. */
   @Override
   public void clearAttachments() {
     attachments.clear();
+
+    for (final IScopeObserver observer : options.getScopeObservers()) {
+      observer.clearAttachments();
+    }
   }
 
   /**
diff --git a/sentry/src/main/java/io/sentry/ScopeObserverAdapter.java b/sentry/src/main/java/io/sentry/ScopeObserverAdapter.java
index f0ec6448e03..4f6a5ac842c 100644
--- a/sentry/src/main/java/io/sentry/ScopeObserverAdapter.java
+++ b/sentry/src/main/java/io/sentry/ScopeObserverAdapter.java
@@ -57,4 +57,10 @@ public void setTrace(@Nullable SpanContext spanContext, @NotNull IScope scope) {
 
   @Override
   public void setReplayId(@NotNull SentryId replayId) {}
+
+  @Override
+  public void addAttachment(@NotNull Attachment attachment) {}
+
+  @Override
+  public void clearAttachments() {}
 }

From 22ff2c7a3bc300b075ba2755d93ad1482e3c75cb Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Mon, 30 Mar 2026 16:42:03 +0200
Subject: [PATCH 084/391] chore: Add THIRD_PARTY_NOTICES.md for vendored
 third-party code (#5186)

* chore: Add THIRD_PARTY_NOTICES.md for vendored third-party code

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore: Add changelog entry for THIRD_PARTY_NOTICES.md

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix changelog section name

* Update CHANGELOG.md

Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>

* chore: Bundle THIRD_PARTY_NOTICES.md in sentry JAR under META-INF

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 CHANGELOG.md            |   1 +
 THIRD_PARTY_NOTICES.md  | 458 ++++++++++++++++++++++++++++++++++++++++
 sentry/build.gradle.kts |   4 +
 3 files changed, 463 insertions(+)
 create mode 100644 THIRD_PARTY_NOTICES.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ac9f9654836..b097b0790bf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Features
 
 - Android: Attachments on the scope will now be synced to native ([#5211](https://github.com/getsentry/sentry-java/pull/5211))
+- Add THIRD_PARTY_NOTICES.md for vendored third-party code, bundled as SENTRY_THIRD_PARTY_NOTICES.md in the sentry JAR under META-INF ([#5186](https://github.com/getsentry/sentry-java/pull/5186))
 
 ## 8.37.1
 
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
new file mode 100644
index 00000000000..8b2141cc59e
--- /dev/null
+++ b/THIRD_PARTY_NOTICES.md
@@ -0,0 +1,458 @@
+# Third-Party Software Notices and Information
+
+The Sentry Java SDK distribution includes software developed by third parties which carry their own copyright notices and license terms. These notices are provided below.
+
+In the event that a required notice is missing or incorrect, please inform us by creating an issue [here](https://github.com/getsentry/sentry-java/issues).
+
+---
+
+## Google GSON (Apache 2.0)
+
+**Source:** https://github.com/google/gson (Tag: gson-parent-2.8.7)<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright (C) 2010 Google Inc.
+
+### Scope
+
+The Sentry Java SDK includes vendored JSON stream reading and writing classes extracted from the GSON library. The code resides in the `io.sentry.vendor.gson.stream` package and includes `JsonReader`, `JsonWriter`, `JsonScope`, `JsonToken`, and `MalformedJsonException`.
+
+```
+Copyright (C) 2010 Google Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## FasterXML Jackson — ISO8601Utils (Apache 2.0)
+
+**Source:** https://github.com/FasterXML/jackson-databind<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright (C) 2007-, Tatu Saloranta
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of `ISO8601Utils` from the Jackson Databind library for ISO 8601 date/time parsing and formatting. The code resides in `io.sentry.vendor.gson.internal.bind.util.ISO8601Utils`.
+
+```
+Copyright (C) 2007-, Tatu Saloranta
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## Android Open Source Project — Base64 (Apache 2.0)
+
+**Source:** https://cs.android.com/android/platform/superproject/main/+/main:frameworks/base/core/java/android/util/Base64.java<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright (C) 2010 The Android Open Source Project
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of the Android `Base64` class for Base64 encoding and decoding on non-Android platforms. The code resides in `io.sentry.vendor.Base64`.
+
+```
+Copyright (C) 2010 The Android Open Source Project
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## Square — Tape (Apache 2.0)
+
+**Source:** https://github.com/square/tape (Commit: 445cd3fd0a7b3ec48c9ea3e0e86663fe6d3735d8)<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright (C) 2010 Square, Inc.
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of Square's Tape library, a file-based FIFO queue implementation used for reliable event storage. The code resides in the `io.sentry.cache.tape` package and includes `QueueFile`, `FileObjectQueue`, and `ObjectQueue`.
+
+```
+Copyright (C) 2010 Square, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## Square — Curtains (Apache 2.0)
+
+**Source:** https://github.com/square/curtains (v1.2.5)<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright 2021 Square Inc.
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of Square's Curtains library for null-safe `Window.Callback` handling. The code resides in `io.sentry.android.replay.util.FixedWindowCallback`.
+
+```
+Copyright 2021 Square Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## Apache Commons Collections (Apache 2.0)
+
+**Source:** https://github.com/apache/commons-collections<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright The Apache Software Foundation
+
+### Scope
+
+The Sentry Java SDK includes adapted versions of `CircularFifoQueue`, `SynchronizedCollection`, and `SynchronizedQueue` from Apache Commons Collections. The code resides in `io.sentry.CircularFifoQueue`, `io.sentry.SynchronizedCollection`, and `io.sentry.SynchronizedQueue`.
+
+```
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements.  See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to You under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## Matej Tymes — JavaFixes (Apache 2.0)
+
+**Source:** https://github.com/MatejTymes/JavaFixes (Commit: 37e74b9d0a29f7a47485c6d1bb1307f01fb93634)<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright (C) 2016 Matej Tymes
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of `ReusableCountLatch` from the JavaFixes library for concurrent synchronization. The code resides in `io.sentry.transport.ReusableCountLatch`.
+
+```
+Copyright (C) 2016 Matej Tymes
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## Baomidou — Dynamic-Datasource (Apache 2.0)
+
+**Source:** https://github.com/baomidou/dynamic-datasource<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright © 2018 organization baomidou
+
+### Scope
+
+The Sentry Java SDK includes an adapted UUID generation implementation from the Dynamic-Datasource library. The code resides in `io.sentry.util.UUIDGenerator`.
+
+```
+Copyright © 2018 organization baomidou
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## Google Firebase — Android SDK (Apache 2.0)
+
+**Source:** https://github.com/firebase/firebase-android-sdk<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright 2022 Google LLC
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of `FirstDrawDoneListener` from the Firebase Android SDK for detecting initial display time via `OnDrawListener`. The code resides in `io.sentry.android.core.internal.util.FirstDrawDoneListener`.
+
+```
+Copyright 2022 Google LLC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## Android Open Source Project — Thread Dump Parsing (Apache 2.0)
+
+**Source:** https://cs.android.com/android/platform/superproject/+/master:development/tools/bugreport/src/com/android/bugreport/stacks/ThreadSnapshotParser.java<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright (C) 2016 The Android Open Source Project
+
+### Scope
+
+The Sentry Java SDK includes adapted thread state and stack trace parsing code from the Android Open Source Project's bugreport tools. The code resides in the `io.sentry.android.core.internal.threaddump` package and includes `ThreadDumpParser`, `Line`, and `Lines`.
+
+```
+Copyright (C) 2016 The Android Open Source Project
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## OpenTelemetry (Apache 2.0)
+
+**Source:** https://github.com/open-telemetry/opentelemetry-java (Commit: 0aacc55d1e3f5cc6dbb4f8fa26bcb657b01a7bc9)<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright The OpenTelemetry Authors
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of `ThreadLocalContextStorage` from the OpenTelemetry Java SDK for thread-local context storage. The code resides in `io.sentry.opentelemetry.SentryOtelThreadLocalStorage`.
+
+```
+Copyright The OpenTelemetry Authors
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## SalomonBrys — ANR-WatchDog (MIT)
+
+**Source:** https://github.com/SalomonBrys/ANR-WatchDog (Commit: 1969075f75f5980e9000eaffbaa13b0daf282dcb)<br>
+**License:** MIT License<br>
+**Copyright:** Copyright (c) 2016 Salomon BRYS
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of the ANR-WatchDog library for Application Not Responding (ANR) detection on Android. The code resides in `io.sentry.android.core.ANRWatchDog`.
+
+```
+MIT License
+
+Copyright (c) 2016 Salomon BRYS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
+---
+
+## Breadwallet — Root Detection (MIT)
+
+**Source:** https://github.com/Menwitz/ravencoin-android (adapted from breadwallet)<br>
+**License:** MIT License<br>
+**Copyright:** Copyright (c) 2016 breadwallet LLC
+
+### Scope
+
+The Sentry Java SDK includes an adapted root detection implementation from the Ravencoin Android wallet (originally from breadwallet). The code resides in `io.sentry.android.core.internal.util.RootChecker`.
+
+```
+MIT License
+
+Copyright (c) 2016 breadwallet LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+```
+
+---
+
+## KilianB — PCG-Java (MIT)
+
+**Source:** https://github.com/KilianB/pcg-java<br>
+**License:** MIT License<br>
+**Copyright:** Copyright (c) 2018
+
+### Scope
+
+The Sentry Java SDK includes an adapted PCG-based random number generator from the pcg-java library for fast sampling. The code resides in `io.sentry.util.Random`.
+
+```
+MIT License
+
+Copyright (c) 2018
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+---
+
+## Jon Chambers — UUID String Utils (MIT)
+
+**Source:** Jon Chambers<br>
+**License:** MIT License<br>
+**Copyright:** Copyright (c) 2018 Jon Chambers
+
+### Scope
+
+The Sentry Java SDK includes adapted UUID string manipulation utilities. The code resides in `io.sentry.util.UUIDStringUtils`.
+
+```
+MIT License
+
+Copyright (c) 2018 Jon Chambers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
diff --git a/sentry/build.gradle.kts b/sentry/build.gradle.kts
index bbeb9cc62df..25e700995b4 100644
--- a/sentry/build.gradle.kts
+++ b/sentry/build.gradle.kts
@@ -95,6 +95,10 @@ tasks.withType<JavaCompile>().configureEach {
 }
 
 tasks.jar {
+  from(rootProject.file("THIRD_PARTY_NOTICES.md")) {
+    into("META-INF")
+    rename { "SENTRY_THIRD_PARTY_NOTICES.md" }
+  }
   manifest {
     attributes(
       "Sentry-Version-Name" to project.version,

From 96c9c721415eb3b1d058e6650143fdcebd8461ae Mon Sep 17 00:00:00 2001
From: Giannis Gkiortzis <58184179+giortzisg@users.noreply.github.com>
Date: Tue, 31 Mar 2026 08:35:57 +0200
Subject: [PATCH 085/391] feat: Add strict trace continuation support (#5136)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat: Add strict trace continuation support

Extract org ID from DSN host, add strictTraceContinuation and orgId
options, propagate sentry-org_id in baggage, and validate incoming
traces per the decision matrix.

Closes #5128

* Format code

* Add changelog entry

* Update API surface file for strict trace continuation

Add public API declarations for new org ID and strict trace
continuation methods on Baggage, PropagationContext, and SentryOptions.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Address review comments for strict trace continuation

- Make Dsn.orgId final, remove unnecessary setter
- Fix test signatures to use List<String> for baggage headers
- Add strictTraceContinuation and orgId to ExternalOptions and merge()
- Add options to ManifestMetadataReader for Android manifest config
- Use Sentry.getCurrentScopes().getOptions() in legacy fromHeaders overload
- Improve CHANGELOG description with details about new options
- Update API surface file for ExternalOptions changes

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Fix compilation errors after rebase on main

- Add comment to empty catch block in PropagationContext to satisfy -Werror
- Add setOrgId setter to Dsn class (remove final modifier on orgId field) to
  support the existing test for org ID override

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: Move changelog entry to Unreleased section

* Format code

* fix: Address review comments — pass options to PropagationContext, fix OTel overload, add option tests, make Dsn.orgId final

- Remove PropagationContext.fromHeaders overload without SentryOptions; all
  callers now pass options (or null) explicitly instead of relying on
  Sentry.getCurrentScopes()
- Add SentryOptions parameter to the OTel-facing fromHeaders(SentryTraceHeader,
  Baggage, SpanId) overload so OpenTelemetry integrations also check orgId
- Make Dsn.orgId final and remove the setter — orgId is only set during
  DSN parsing in the constructor
- Add tests for strictTraceContinuation and orgId options in
  ExternalOptionsTest, SentryOptionsTest, and ManifestMetadataReaderTest
- Improve CHANGELOG entry with customer-facing description
- Update API declarations (apiDump)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix: Add missing 8.34.1 changelog section

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Format code

* fix: Address PR review comments for strict trace continuation

- Remove duplicated org ID check in PropagationContext.fromHeaders, pass
  options through to the single-check overload instead
- Add debug log when trace is not continued in the SentryTraceHeader overload
- Handle empty/blank org ID strings in shouldContinueTrace to avoid
  silently breaking traces
- Update OtelSentrySpanProcessor to use PropagationContext.fromHeaders
  with options for org_id validation
- Rename ExternalOptions property key to enable-strict-trace-continuation
  (matching the enable- prefix convention for newer options)
- Update ExternalOptionsTest to use the new property key
- Add strict-trace-continuation and org-id properties to all 3 Spring
  Boot SentryAutoConfigurationTest modules
- Improve CHANGELOG entry with detailed customer-facing descriptions
  and configuration examples for all options

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Format code

* fix(tracing): Clarify strict org validation debug log

Update the trace-continuation rejection log message to cover all strict org ID validation failures, including missing org IDs, not just mismatches.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(android): Use enabled suffix for strict trace manifest key

Rename the Android manifest option to io.sentry.strict-trace-continuation.enabled to align with existing enabled-style manifest flags.

Update changelog documentation to match the new Android key.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(api): Mark effective org ID helper as internal

Annotate SentryOptions.getEffectiveOrgId with ApiStatus.Internal since it is used as an internal helper for trace propagation org ID resolution.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(tracing): Extract trace continuation decision into TracingUtils

Move strict trace continuation org-id validation logic to TracingUtils
so it can be reused by tracing entry points.

Update PropagationContext to call the shared helper and add dedicated
TracingUtils tests for strict/non-strict org-id continuation outcomes.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(opentelemetry): Enforce strict continuation in propagators

Apply strict trace continuation checks in all OpenTelemetry propagator
extract paths before creating remote parent span context.

When org-id validation fails, return the original context and ignore
incoming sentry-trace and baggage to keep propagation behavior aligned
with strict continuation requirements.

Add rejection tests for OtelSentryPropagator, deprecated
SentryPropagator, and OpenTelemetryOtlpPropagator.

Co-Authored-By: Claude <noreply@anthropic.com>

* Format code

* fix(tracing): Fix empty orgId bypassing DSN fallback

The getEffectiveOrgId() method only checked orgId != null, allowing
empty strings and whitespace-only values to bypass the DSN fallback
mechanism. This caused empty org IDs to propagate to outgoing baggage
headers as sentry-org_id=, silently breaking trace continuation in
strict mode.

Update getEffectiveOrgId() to trim the orgId value and check if it's
empty after trimming. Empty or blank values now correctly fall back
to the DSN org ID instead of propagating as empty strings.

Add comprehensive test coverage for all edge cases including empty
strings, whitespace-only values, and their impact on baggage
propagation and strict trace continuation.

Co-Authored-By: Claude <noreply@anthropic.com>

* Format code

* ref: Remove redundant trim of already-trimmed effective org ID

getEffectiveOrgId() already guarantees it returns either null or a
trimmed, non-empty string. The defensive trim and empty check in
shouldContinueTrace was dead code that could never change the result.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(tracing): Revert shouldContinueTrace check in OtelSentrySpanProcessor

The propagator is the correct enforcement point for org ID validation.
By the time the span processor runs, OTel has already created the span
with the remote parent's trace ID. If shouldContinueTrace rejects here,
it creates a fresh PropagationContext with a mismatched trace ID rather
than cleanly rejecting the trace.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(test): Clean up global Sentry state in SentryPropagatorTest

SentryPropagatorTest calls Sentry.init with strict trace continuation
but never closes Sentry afterward. This leaks global state into
SentrySpanProcessorTest where SentryPropagator uses the global
ScopesAdapter and rejects incoming sentry-trace headers under the
leaked strict mode configuration.

Add @AfterTest that calls Sentry.close() to prevent state leakage.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(test): Use mock scopes in propagator strict continuation tests

The strict continuation tests called Sentry.init with strict mode and
org ID configuration, which leaked global state into other tests.
Sentry.close() does not fully reset the global scope options, so
SentrySpanProcessorTest's SentryPropagator (using ScopesAdapter) would
reject incoming sentry-trace headers.

Use the package-private constructor with mock IScopes instead of
relying on global Sentry state for strict continuation validation.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(test): Reset OTel context in propagator test teardown

Sentry.init uses OtelContextScopesStorage which pushes scopes onto the
OTel context via makeCurrent(). The returned pop-token is discarded by
Sentry.init, and OtelContextScopesStorage.close() is a no-op, so
Sentry.close() alone does not restore the OTel context.

Since JUnit reuses the same thread across test classes, stale scopes
from SentryPropagatorTest (with strict continuation enabled) leaked
into SentrySpanProcessorTest via Context.current().

Add Context.root().makeCurrent() after Sentry.close() in all
propagator test teardowns to reset the thread-local OTel context.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(test): Add back test for inject with invalid span

The previous commit replaced the invalid-span inject test with a
no-span-in-context test. These are distinct scenarios: an explicitly
invalid span vs no span at all. Restore the invalid span test and
keep both.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Alexander Dinauer <alexander.dinauer@sentry.io>
Co-authored-by: Alexander Dinauer <adinauer@users.noreply.github.com>
---
 CHANGELOG.md                                  |   4 +
 .../android/core/ManifestMetadataReader.java  |  12 ++
 .../core/ManifestMetadataReaderTest.kt        |  50 ++++++
 .../opentelemetry/OtelSentryPropagator.java   |   8 +
 .../opentelemetry/SentryPropagator.java       |  15 +-
 .../sentry/opentelemetry/SentrySampler.java   |   3 +-
 .../opentelemetry/SentrySpanProcessor.java    |   5 +-
 .../test/kotlin/OtelSentryPropagatorTest.kt   |  23 +++
 .../src/test/kotlin/SentryPropagatorTest.kt   |  48 +++++
 .../otlp/OpenTelemetryOtlpPropagator.java     |  16 +-
 .../test/kotlin/OtelSentryPropagatorTest.kt   | 151 ++++++++++------
 .../tracing/SentryTracingFilterTest.kt        |   1 +
 .../webflux/SentryWebFluxTracingFilterTest.kt |   1 +
 .../boot4/SentryAutoConfigurationTest.kt      |   4 +
 .../jakarta/SentryAutoConfigurationTest.kt    |   4 +
 .../boot/SentryAutoConfigurationTest.kt       |   4 +
 .../tracing/SentryTracingFilterTest.kt        |   1 +
 .../webflux/SentryWebFluxTracingFilterTest.kt |   1 +
 .../spring/tracing/SentryTracingFilterTest.kt |   1 +
 .../webflux/SentryWebFluxTracingFilterTest.kt |   1 +
 sentry/api/sentry.api                         |  19 +-
 sentry/src/main/java/io/sentry/Baggage.java   |  17 +-
 sentry/src/main/java/io/sentry/Dsn.java       |  20 +++
 .../main/java/io/sentry/ExternalOptions.java  |  23 +++
 .../java/io/sentry/PropagationContext.java    |  21 ++-
 sentry/src/main/java/io/sentry/Scopes.java    |   3 +-
 .../main/java/io/sentry/SentryOptions.java    |  57 ++++++
 .../java/io/sentry/util/TracingUtils.java     |  26 +++
 sentry/src/test/java/io/sentry/BaggageTest.kt |  85 +++++++++
 sentry/src/test/java/io/sentry/DsnTest.kt     |  24 +++
 .../java/io/sentry/ExternalOptionsTest.kt     |  29 ++++
 .../java/io/sentry/PropagationContextTest.kt  | 164 ++++++++++++++++++
 .../test/java/io/sentry/SentryOptionsTest.kt  | 108 ++++++++++++
 .../java/io/sentry/TransactionContextTest.kt  |   4 +
 .../java/io/sentry/util/TracingUtilsTest.kt   |  80 +++++++++
 35 files changed, 963 insertions(+), 70 deletions(-)
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentryPropagatorTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b097b0790bf..6bd3b127948 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@
 
 ### Features
 
+- Prevent cross-organization trace continuation ([#5136](https://github.com/getsentry/sentry-java/pull/5136))
+  - By default, the SDK now extracts the organization ID from the DSN (e.g. `o123.ingest.sentry.io`) and compares it with the `sentry-org_id` value in incoming baggage headers. When the two differ, the SDK starts a fresh trace instead of continuing the foreign one. This guards against accidentally linking traces across organizations.
+  - New option `enableStrictTraceContinuation` (default `false`): when enabled, both the SDK's org ID **and** the incoming baggage org ID must be present and match for a trace to be continued. Traces with a missing org ID on either side are rejected. Configurable via code (`setStrictTraceContinuation(true)`), `sentry.properties` (`enable-strict-trace-continuation=true`), Android manifest (`io.sentry.strict-trace-continuation.enabled`), or Spring Boot (`sentry.strict-trace-continuation=true`).
+  - New option `orgId`: allows explicitly setting the organization ID for self-hosted and Relay setups where it cannot be extracted from the DSN. Configurable via code (`setOrgId("123")`), `sentry.properties` (`org-id=123`), Android manifest (`io.sentry.org-id`), or Spring Boot (`sentry.org-id=123`).
 - Android: Attachments on the scope will now be synced to native ([#5211](https://github.com/getsentry/sentry-java/pull/5211))
 - Add THIRD_PARTY_NOTICES.md for vendored third-party code, bundled as SENTRY_THIRD_PARTY_NOTICES.md in the sentry JAR under META-INF ([#5186](https://github.com/getsentry/sentry-java/pull/5186))
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 822d7fbbe08..6d90bb5ca8e 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -167,6 +167,9 @@ final class ManifestMetadataReader {
 
   static final String FEEDBACK_SHOW_BRANDING = "io.sentry.feedback.show-branding";
 
+  static final String STRICT_TRACE_CONTINUATION = "io.sentry.strict-trace-continuation.enabled";
+  static final String ORG_ID = "io.sentry.org-id";
+
   static final String FEEDBACK_USE_SHAKE_GESTURE = "io.sentry.feedback.use-shake-gesture";
 
   static final String SPOTLIGHT_ENABLE = "io.sentry.spotlight.enable";
@@ -667,6 +670,15 @@ static void applyMetadata(
             readBool(
                 metadata, logger, FEEDBACK_USE_SHAKE_GESTURE, feedbackOptions.isUseShakeGesture()));
 
+        options.setStrictTraceContinuation(
+            readBool(
+                metadata, logger, STRICT_TRACE_CONTINUATION, options.isStrictTraceContinuation()));
+
+        final @Nullable String orgId = readString(metadata, logger, ORG_ID, null);
+        if (orgId != null) {
+          options.setOrgId(orgId);
+        }
+
         options.setEnableSpotlight(
             readBool(metadata, logger, SPOTLIGHT_ENABLE, options.isEnableSpotlight()));
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index ba01a9ecf7a..81b73d5dea7 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -2461,4 +2461,54 @@ class ManifestMetadataReaderTest {
     // maskAllImages should also add WebView
     assertTrue(fixture.options.screenshot.maskViewClasses.contains("android.webkit.WebView"))
   }
+
+  @Test
+  fun `applyMetadata reads strictTraceContinuation and keeps default value if not found`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertFalse(fixture.options.isStrictTraceContinuation)
+  }
+
+  @Test
+  fun `applyMetadata reads strictTraceContinuation to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.STRICT_TRACE_CONTINUATION to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.isStrictTraceContinuation)
+  }
+
+  @Test
+  fun `applyMetadata reads orgId and keeps null if not found`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertNull(fixture.options.orgId)
+  }
+
+  @Test
+  fun `applyMetadata reads orgId to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.ORG_ID to "12345")
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals("12345", fixture.options.orgId)
+  }
 }
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSentryPropagator.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSentryPropagator.java
index 56e87c67896..e87af070748 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSentryPropagator.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSentryPropagator.java
@@ -113,6 +113,14 @@ public <C> Context extract(
 
       final @Nullable String baggageString = getter.get(carrier, BaggageHeader.BAGGAGE_HEADER);
       final Baggage baggage = Baggage.fromHeader(baggageString);
+      if (!TracingUtils.shouldContinueTrace(scopes.getOptions(), baggage)) {
+        scopes
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.DEBUG, "Not continuing trace due to strict org ID validation failure.");
+        return context;
+      }
       final @NotNull TraceState traceState = TraceState.getDefault();
 
       SpanContext otelSpanContext =
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentryPropagator.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentryPropagator.java
index ffcab9ed541..4016debf2bb 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentryPropagator.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentryPropagator.java
@@ -16,6 +16,7 @@
 import io.sentry.SentryLevel;
 import io.sentry.SentryTraceHeader;
 import io.sentry.exception.InvalidSentryTraceHeaderException;
+import io.sentry.util.TracingUtils;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
@@ -98,6 +99,17 @@ public <C> Context extract(
     try {
       SentryTraceHeader sentryTraceHeader = new SentryTraceHeader(sentryTraceString);
 
+      final @Nullable String baggageString = getter.get(carrier, BaggageHeader.BAGGAGE_HEADER);
+      Baggage baggage = Baggage.fromHeader(baggageString);
+      if (!TracingUtils.shouldContinueTrace(scopes.getOptions(), baggage)) {
+        scopes
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.DEBUG, "Not continuing trace due to strict org ID validation failure.");
+        return context;
+      }
+
       SpanContext otelSpanContext =
           SpanContext.createFromRemoteParent(
               sentryTraceHeader.getTraceId().toString(),
@@ -107,9 +119,6 @@ public <C> Context extract(
 
       @NotNull
       Context modifiedContext = context.with(SentryOtelKeys.SENTRY_TRACE_KEY, sentryTraceHeader);
-
-      final @Nullable String baggageString = getter.get(carrier, BaggageHeader.BAGGAGE_HEADER);
-      Baggage baggage = Baggage.fromHeader(baggageString);
       modifiedContext = modifiedContext.with(SentryOtelKeys.SENTRY_BAGGAGE_KEY, baggage);
 
       Span wrappedSpan = Span.wrap(otelSpanContext);
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySampler.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySampler.java
index 5493ba033cb..1a9e8724ca6 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySampler.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySampler.java
@@ -91,7 +91,8 @@ public SamplingResult shouldSample(
     final @NotNull PropagationContext propagationContext =
         sentryTraceHeader == null
             ? new PropagationContext(new SentryId(traceId), randomSpanId, null, baggage, null)
-            : PropagationContext.fromHeaders(sentryTraceHeader, baggage, randomSpanId);
+            : PropagationContext.fromHeaders(
+                sentryTraceHeader, baggage, randomSpanId, scopes.getOptions());
 
     final @NotNull TransactionContext transactionContext =
         TransactionContext.fromPropagationContext(propagationContext);
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanProcessor.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanProcessor.java
index 2b650ef9dd2..9c6a51f17c3 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanProcessor.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanProcessor.java
@@ -127,7 +127,10 @@ public void onStart(final @NotNull Context parentContext, final @NotNull ReadWri
                   new SentryId(traceData.getTraceId()), spanId, null, null, null)
               : TransactionContext.fromPropagationContext(
                   PropagationContext.fromHeaders(
-                      traceData.getSentryTraceHeader(), traceData.getBaggage(), spanId));
+                      traceData.getSentryTraceHeader(),
+                      traceData.getBaggage(),
+                      spanId,
+                      scopes.getOptions()));
       ;
       transactionContext.setName(transactionName);
       transactionContext.setTransactionNameSource(transactionNameSource);
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelSentryPropagatorTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelSentryPropagatorTest.kt
index 2315412fd46..6b9e733157d 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelSentryPropagatorTest.kt
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelSentryPropagatorTest.kt
@@ -19,6 +19,7 @@ import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertSame
@@ -38,6 +39,8 @@ class OtelSentryPropagatorTest {
   @AfterTest
   fun cleanup() {
     spanStorage.clear()
+    Sentry.close()
+    Context.root().makeCurrent()
   }
 
   @Test
@@ -69,6 +72,26 @@ class OtelSentryPropagatorTest {
     assertSame(scopeInContext, scopes)
   }
 
+  @Test
+  fun `ignores incoming headers when strict continuation rejects org id`() {
+    Sentry.init { options ->
+      options.dsn = "https://key@o2.ingest.sentry.io/123"
+      options.isStrictTraceContinuation = true
+    }
+    val propagator = OtelSentryPropagator()
+    val carrier: Map<String, String> =
+      mapOf(
+        "sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1",
+        "baggage" to "sentry-trace_id=f9118105af4a2d42b4124532cd1065ff,sentry-org_id=1",
+      )
+
+    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
+
+    assertFalse(Span.fromContext(newContext).spanContext.isValid)
+    assertNull(newContext.get(SENTRY_TRACE_KEY))
+    assertNull(newContext.get(SENTRY_BAGGAGE_KEY))
+  }
+
   @Test
   fun `uses incoming headers`() {
     val propagator = OtelSentryPropagator()
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentryPropagatorTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentryPropagatorTest.kt
new file mode 100644
index 00000000000..29e820acff0
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SentryPropagatorTest.kt
@@ -0,0 +1,48 @@
+package io.sentry.opentelemetry
+
+import io.opentelemetry.api.trace.Span
+import io.opentelemetry.context.Context
+import io.sentry.Sentry
+import io.sentry.opentelemetry.SentryOtelKeys.SENTRY_BAGGAGE_KEY
+import io.sentry.opentelemetry.SentryOtelKeys.SENTRY_TRACE_KEY
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+
+class SentryPropagatorTest {
+
+  @BeforeTest
+  fun setup() {
+    Sentry.init("https://key@sentry.io/proj")
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+    Context.root().makeCurrent()
+  }
+
+  @Suppress("DEPRECATION")
+  @Test
+  fun `ignores incoming headers when strict continuation rejects org id`() {
+    Sentry.init { options ->
+      options.dsn = "https://key@o2.ingest.sentry.io/123"
+      options.isStrictTraceContinuation = true
+    }
+
+    val propagator = SentryPropagator()
+    val carrier: Map<String, String> =
+      mapOf(
+        "sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1",
+        "baggage" to "sentry-trace_id=f9118105af4a2d42b4124532cd1065ff,sentry-org_id=1",
+      )
+
+    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
+
+    assertFalse(Span.fromContext(newContext).spanContext.isValid)
+    assertNull(newContext.get(SENTRY_TRACE_KEY))
+    assertNull(newContext.get(SENTRY_BAGGAGE_KEY))
+  }
+}
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java
index e6bc31ca827..a4249b27ec0 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java
@@ -18,6 +18,7 @@
 import io.sentry.SentryLevel;
 import io.sentry.SentryTraceHeader;
 import io.sentry.exception.InvalidSentryTraceHeaderException;
+import io.sentry.util.TracingUtils;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
@@ -87,6 +88,16 @@ public <C> Context extract(
       SentryTraceHeader sentryTraceHeader = new SentryTraceHeader(sentryTraceString);
 
       final @Nullable String baggageString = getter.get(carrier, BaggageHeader.BAGGAGE_HEADER);
+      final @Nullable Baggage baggage =
+          baggageString == null ? null : Baggage.fromHeader(baggageString);
+      if (!TracingUtils.shouldContinueTrace(scopes.getOptions(), baggage)) {
+        scopes
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.DEBUG, "Not continuing trace due to strict org ID validation failure.");
+        return context;
+      }
       final @NotNull TraceState traceState = TraceState.getDefault();
 
       final @NotNull TraceFlags traceFlags =
@@ -104,9 +115,8 @@ public <C> Context extract(
       Span wrappedSpan = Span.wrap(otelSpanContext);
 
       @NotNull Context modifiedContext = context.with(wrappedSpan);
-      if (baggageString != null) {
-        modifiedContext =
-            modifiedContext.with(SENTRY_BAGGAGE_KEY, Baggage.fromHeader(baggageString));
+      if (baggage != null) {
+        modifiedContext = modifiedContext.with(SENTRY_BAGGAGE_KEY, baggage);
       }
 
       scopes
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt
index e9bfe26c11d..1d5d56c5bff 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt
@@ -9,6 +9,7 @@ import io.opentelemetry.context.propagation.TextMapGetter
 import io.opentelemetry.context.propagation.TextMapSetter
 import io.sentry.Baggage
 import io.sentry.Sentry
+import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -23,6 +24,12 @@ class OpenTelemetryOtlpPropagatorTest {
     Sentry.init("https://key@sentry.io/proj")
   }
 
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+    Context.root().makeCurrent()
+  }
+
   @Test
   fun `propagator registers for sentry-trace and baggage`() {
     val propagator = OpenTelemetryOtlpPropagator()
@@ -46,6 +53,25 @@ class OpenTelemetryOtlpPropagatorTest {
     assertNull(baggage)
   }
 
+  @Test
+  fun `ignores incoming headers when strict continuation rejects org id`() {
+    Sentry.init { options ->
+      options.dsn = "https://key@o2.ingest.sentry.io/123"
+      options.isStrictTraceContinuation = true
+    }
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier: Map<String, String> =
+      mapOf(
+        "sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1",
+        "baggage" to "sentry-trace_id=f9118105af4a2d42b4124532cd1065ff,sentry-org_id=1",
+      )
+
+    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
+
+    assertFalse(Span.fromContext(newContext).spanContext.isValid)
+    assertNull(newContext.get(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY))
+  }
+
   @Test
   fun `uses incoming headers`() {
     val propagator = OpenTelemetryOtlpPropagator()
@@ -55,74 +81,65 @@ class OpenTelemetryOtlpPropagatorTest {
         "baggage" to
           "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d",
       )
+
     val newContext = propagator.extract(Context.root(), carrier, MapGetter())
 
     val span = Span.fromContext(newContext)
+    assertTrue(span.spanContext.isValid)
     assertEquals("f9118105af4a2d42b4124532cd1065ff", span.spanContext.traceId)
     assertEquals("424cffc8f94feeee", span.spanContext.spanId)
-    assertTrue(span.spanContext.isSampled)
 
-    assertEquals(
-      "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d",
-      newContext.get(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY)?.toHeaderString(null),
-    )
+    val baggage = newContext.get(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY)
+    assertEquals("production", baggage?.environment)
   }
 
   @Test
-  fun `extract does not store baggage in context when baggage header is missing`() {
+  fun `extract sets sampled trace flag when sentry-trace has sampled=0`() {
     val propagator = OpenTelemetryOtlpPropagator()
     val carrier: Map<String, String> =
-      mapOf("sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1")
-    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
-
-    assertNull(newContext.get(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY))
-  }
-
-  @Test
-  fun `does not inject baggage header when baggage is missing from context`() {
-    val propagator = OpenTelemetryOtlpPropagator()
-    val carrier = mutableMapOf<String, String>()
-
-    val otelSpanContext =
-      SpanContext.create(
-        "f9118105af4a2d42b4124532cd1065ff",
-        "424cffc8f94feeee",
-        TraceFlags.getSampled(),
-        TraceState.getDefault(),
+      mapOf(
+        "sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-0",
+        "baggage" to
+          "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=false,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d",
       )
-    val otelSpan = Span.wrap(otelSpanContext)
-    val context = Context.root().with(otelSpan)
 
-    propagator.inject(context, carrier, MapSetter())
+    val newContext = propagator.extract(Context.root(), carrier, MapGetter())
 
-    assertEquals("f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1", carrier["sentry-trace"])
-    assertNull(carrier["baggage"])
+    val span = Span.fromContext(newContext)
+    assertTrue(span.spanContext.isValid)
+    assertFalse(span.spanContext.traceFlags.isSampled)
   }
 
   @Test
-  fun `extract sets sampled trace flag when sentry-trace has sampled=0`() {
+  fun `extract sets sampled trace flag when sentry-trace has no sampling decision`() {
     val propagator = OpenTelemetryOtlpPropagator()
     val carrier: Map<String, String> =
-      mapOf("sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-0")
+      mapOf(
+        "sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee",
+        "baggage" to
+          "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d",
+      )
+
     val newContext = propagator.extract(Context.root(), carrier, MapGetter())
 
     val span = Span.fromContext(newContext)
-    assertEquals("f9118105af4a2d42b4124532cd1065ff", span.spanContext.traceId)
-    assertEquals("424cffc8f94feeee", span.spanContext.spanId)
-    assertFalse(span.spanContext.isSampled)
+    assertTrue(span.spanContext.isValid)
+    assertTrue(span.spanContext.traceFlags.isSampled)
   }
 
   @Test
-  fun `extract sets sampled trace flag when sentry-trace has no sampling decision`() {
+  fun `extract does not store baggage in context when baggage header is missing`() {
     val propagator = OpenTelemetryOtlpPropagator()
     val carrier: Map<String, String> =
-      mapOf("sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee")
+      mapOf("sentry-trace" to "f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1")
+
     val newContext = propagator.extract(Context.root(), carrier, MapGetter())
 
     val span = Span.fromContext(newContext)
-    assertEquals("f9118105af4a2d42b4124532cd1065ff", span.spanContext.traceId)
-    assertEquals("424cffc8f94feeee", span.spanContext.spanId)
-    assertTrue(span.spanContext.isSampled)
+    assertTrue(span.spanContext.isValid)
+
+    val baggage = newContext.get(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY)
+    assertNull(baggage)
   }
 
   @Test
@@ -138,16 +155,12 @@ class OpenTelemetryOtlpPropagatorTest {
         TraceState.getDefault(),
       )
     val otelSpan = Span.wrap(otelSpanContext)
-
+    val baggage =
+      Baggage.fromHeader(
+        "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d"
+      )
     val context =
-      Context.root()
-        .with(otelSpan)
-        .with(
-          OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY,
-          Baggage.fromHeader(
-            "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d"
-          ),
-        )
+      Context.root().with(otelSpan).with(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY, baggage)
 
     propagator.inject(context, carrier, MapSetter())
 
@@ -159,7 +172,18 @@ class OpenTelemetryOtlpPropagatorTest {
   }
 
   @Test
-  fun `does not inject headers if span is invalid`() {
+  fun `does not inject headers when no span in context`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier = mutableMapOf<String, String>()
+
+    propagator.inject(Context.root(), carrier, MapSetter())
+
+    assertNull(carrier["sentry-trace"])
+    assertNull(carrier["baggage"])
+  }
+
+  @Test
+  fun `does not inject headers when span is invalid`() {
     val propagator = OpenTelemetryOtlpPropagator()
     val carrier = mutableMapOf<String, String>()
 
@@ -168,17 +192,40 @@ class OpenTelemetryOtlpPropagatorTest {
     assertNull(carrier["sentry-trace"])
     assertNull(carrier["baggage"])
   }
+
+  @Test
+  fun `does not inject baggage header when baggage is missing from context`() {
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier = mutableMapOf<String, String>()
+
+    val otelSpanContext =
+      SpanContext.create(
+        "f9118105af4a2d42b4124532cd1065ff",
+        "424cffc8f94feeee",
+        TraceFlags.getSampled(),
+        TraceState.getDefault(),
+      )
+    val otelSpan = Span.wrap(otelSpanContext)
+
+    propagator.inject(Context.root().with(otelSpan), carrier, MapSetter())
+
+    assertEquals("f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1", carrier["sentry-trace"])
+    assertNull(carrier["baggage"])
+  }
 }
 
 class MapGetter : TextMapGetter<Map<String, String>> {
-  override fun keys(carrier: Map<String, String>): MutableIterable<String> =
-    carrier.keys.toMutableList()
+  override fun keys(carrier: Map<String, String>): MutableIterable<String> {
+    return carrier.keys.toMutableList()
+  }
 
-  override fun get(carrier: Map<String, String>?, key: String): String? = carrier?.get(key)
+  override fun get(carrier: Map<String, String>?, key: String): String? {
+    return carrier?.get(key)
+  }
 }
 
 class MapSetter : TextMapSetter<MutableMap<String, String>> {
   override fun set(carrier: MutableMap<String, String>?, key: String, value: String) {
-    carrier?.set(key, value)
+    carrier?.put(key, value)
   }
 }
diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt
index f63b5d9631c..9778a6d0154 100644
--- a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt
+++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/tracing/SentryTracingFilterTest.kt
@@ -96,6 +96,7 @@ class SentryTracingFilterTest {
             logger,
             it.arguments[0] as String?,
             it.arguments[1] as List<String>?,
+            null,
           )
         )
       }
diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt
index 495f45ac650..bb14538d921 100644
--- a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt
+++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/webflux/SentryWebFluxTracingFilterTest.kt
@@ -98,6 +98,7 @@ class SentryWebFluxTracingFilterTest {
             logger,
             it.arguments[0] as String?,
             it.arguments[1] as List<String>?,
+            null,
           )
         )
       }
diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt
index 7f30c860bb3..ef1f12aeecf 100644
--- a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt
+++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryAutoConfigurationTest.kt
@@ -244,6 +244,8 @@ class SentryAutoConfigurationTest {
         "sentry.cron.default-failure-issue-threshold=40",
         "sentry.cron.default-recovery-threshold=50",
         "sentry.logs.enabled=true",
+        "sentry.strict-trace-continuation=true",
+        "sentry.org-id=12345",
       )
       .run {
         val options = it.getBean(SentryProperties::class.java)
@@ -299,6 +301,8 @@ class SentryAutoConfigurationTest {
         assertThat(options.cron!!.defaultFailureIssueThreshold).isEqualTo(40L)
         assertThat(options.cron!!.defaultRecoveryThreshold).isEqualTo(50L)
         assertThat(options.logs.isEnabled).isEqualTo(true)
+        assertThat(options.isStrictTraceContinuation).isEqualTo(true)
+        assertThat(options.orgId).isEqualTo("12345")
       }
   }
 
diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt
index f37122812b1..91677d16b4e 100644
--- a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt
+++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryAutoConfigurationTest.kt
@@ -249,6 +249,8 @@ class SentryAutoConfigurationTest {
         "sentry.profile-session-sample-rate=1.0",
         "sentry.profiling-traces-dir-path=tmp/sentry/profiling-traces",
         "sentry.profile-lifecycle=TRACE",
+        "sentry.strict-trace-continuation=true",
+        "sentry.org-id=12345",
       )
       .run {
         val options = it.getBean(SentryProperties::class.java)
@@ -307,6 +309,8 @@ class SentryAutoConfigurationTest {
         assertThat(options.profilingTracesDirPath)
           .startsWith(File("tmp/sentry/profiling-traces").absolutePath)
         assertThat(options.profileLifecycle).isEqualTo(ProfileLifecycle.TRACE)
+        assertThat(options.isStrictTraceContinuation).isEqualTo(true)
+        assertThat(options.orgId).isEqualTo("12345")
       }
   }
 
diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt
index 4ce0bf61208..d9e598d0473 100644
--- a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt
+++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryAutoConfigurationTest.kt
@@ -247,6 +247,8 @@ class SentryAutoConfigurationTest {
         "sentry.profile-session-sample-rate=1.0",
         "sentry.profiling-traces-dir-path=tmp/sentry/profiling-traces",
         "sentry.profile-lifecycle=TRACE",
+        "sentry.strict-trace-continuation=true",
+        "sentry.org-id=12345",
       )
       .run {
         val options = it.getBean(SentryProperties::class.java)
@@ -305,6 +307,8 @@ class SentryAutoConfigurationTest {
         assertThat(options.profilingTracesDirPath)
           .startsWith(File("tmp/sentry/profiling-traces").absolutePath)
         assertThat(options.profileLifecycle).isEqualTo(ProfileLifecycle.TRACE)
+        assertThat(options.isStrictTraceContinuation).isEqualTo(true)
+        assertThat(options.orgId).isEqualTo("12345")
       }
   }
 
diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt
index dfb8376286a..ffdd2b9ad75 100644
--- a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt
+++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/tracing/SentryTracingFilterTest.kt
@@ -96,6 +96,7 @@ class SentryTracingFilterTest {
             logger,
             it.arguments[0] as String?,
             it.arguments[1] as List<String>?,
+            null,
           )
         )
       }
diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt
index b14f1b5910c..f0b8d62e025 100644
--- a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt
+++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/webflux/SentryWebFluxTracingFilterTest.kt
@@ -98,6 +98,7 @@ class SentryWebFluxTracingFilterTest {
             logger,
             it.arguments[0] as String?,
             it.arguments[1] as List<String>?,
+            null,
           )
         )
       }
diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt
index f12517ee19e..f942da342c5 100644
--- a/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt
+++ b/sentry-spring/src/test/kotlin/io/sentry/spring/tracing/SentryTracingFilterTest.kt
@@ -96,6 +96,7 @@ class SentryTracingFilterTest {
             logger,
             it.arguments[0] as String?,
             it.arguments[1] as List<String>?,
+            null,
           )
         )
       }
diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt
index b27c0856106..5d91ec58486 100644
--- a/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt
+++ b/sentry-spring/src/test/kotlin/io/sentry/spring/webflux/SentryWebFluxTracingFilterTest.kt
@@ -98,6 +98,7 @@ class SentryWebFluxTracingFilterTest {
             logger,
             it.arguments[0] as String?,
             it.arguments[1] as List<String>?,
+            null,
           )
         )
       }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 3962c3ef1e2..b9cbb2ae1b2 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -47,6 +47,7 @@ public final class io/sentry/Baggage {
 	public static fun fromHeader (Ljava/util/List;ZLio/sentry/ILogger;)Lio/sentry/Baggage;
 	public fun get (Ljava/lang/String;)Ljava/lang/String;
 	public fun getEnvironment ()Ljava/lang/String;
+	public fun getOrgId ()Ljava/lang/String;
 	public fun getPublicKey ()Ljava/lang/String;
 	public fun getRelease ()Ljava/lang/String;
 	public fun getReplayId ()Ljava/lang/String;
@@ -62,6 +63,7 @@ public final class io/sentry/Baggage {
 	public fun isShouldFreeze ()Z
 	public fun set (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setEnvironment (Ljava/lang/String;)V
+	public fun setOrgId (Ljava/lang/String;)V
 	public fun setPublicKey (Ljava/lang/String;)V
 	public fun setRelease (Ljava/lang/String;)V
 	public fun setReplayId (Ljava/lang/String;)V
@@ -81,6 +83,7 @@ public final class io/sentry/Baggage {
 public final class io/sentry/Baggage$DSCKeys {
 	public static final field ALL Ljava/util/List;
 	public static final field ENVIRONMENT Ljava/lang/String;
+	public static final field ORG_ID Ljava/lang/String;
 	public static final field PUBLIC_KEY Ljava/lang/String;
 	public static final field RELEASE Ljava/lang/String;
 	public static final field REPLAY_ID Ljava/lang/String;
@@ -501,6 +504,7 @@ public final class io/sentry/ExternalOptions {
 	public fun getInAppExcludes ()Ljava/util/List;
 	public fun getInAppIncludes ()Ljava/util/List;
 	public fun getMaxRequestBodySize ()Lio/sentry/SentryOptions$RequestSize;
+	public fun getOrgId ()Ljava/lang/String;
 	public fun getPrintUncaughtStackTrace ()Ljava/lang/Boolean;
 	public fun getProfileLifecycle ()Lio/sentry/ProfileLifecycle;
 	public fun getProfileSessionSampleRate ()Ljava/lang/Double;
@@ -531,6 +535,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 isStrictTraceContinuation ()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
@@ -554,6 +559,7 @@ public final class io/sentry/ExternalOptions {
 	public fun setIgnoredErrors (Ljava/util/List;)V
 	public fun setIgnoredTransactions (Ljava/util/List;)V
 	public fun setMaxRequestBodySize (Lio/sentry/SentryOptions$RequestSize;)V
+	public fun setOrgId (Ljava/lang/String;)V
 	public fun setPrintUncaughtStackTrace (Ljava/lang/Boolean;)V
 	public fun setProfileLifecycle (Lio/sentry/ProfileLifecycle;)V
 	public fun setProfileSessionSampleRate (Ljava/lang/Double;)V
@@ -570,6 +576,7 @@ public final class io/sentry/ExternalOptions {
 	public fun setSessionFlushTimeoutMillis (Ljava/lang/Long;)V
 	public fun setShutdownTimeoutMillis (Ljava/lang/Long;)V
 	public fun setSpotlightConnectionUrl (Ljava/lang/String;)V
+	public fun setStrictTraceContinuation (Ljava/lang/Boolean;)V
 	public fun setTag (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setTracesSampleRate (Ljava/lang/Double;)V
 }
@@ -2277,9 +2284,9 @@ public final class io/sentry/PropagationContext {
 	public fun <init> (Lio/sentry/PropagationContext;)V
 	public fun <init> (Lio/sentry/protocol/SentryId;Lio/sentry/SpanId;Lio/sentry/SpanId;Lio/sentry/Baggage;Ljava/lang/Boolean;)V
 	public static fun fromExistingTrace (Ljava/lang/String;Ljava/lang/String;Ljava/lang/Double;Ljava/lang/Double;)Lio/sentry/PropagationContext;
-	public static fun fromHeaders (Lio/sentry/ILogger;Ljava/lang/String;Ljava/lang/String;)Lio/sentry/PropagationContext;
-	public static fun fromHeaders (Lio/sentry/ILogger;Ljava/lang/String;Ljava/util/List;)Lio/sentry/PropagationContext;
-	public static fun fromHeaders (Lio/sentry/SentryTraceHeader;Lio/sentry/Baggage;Lio/sentry/SpanId;)Lio/sentry/PropagationContext;
+	public static fun fromHeaders (Lio/sentry/ILogger;Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryOptions;)Lio/sentry/PropagationContext;
+	public static fun fromHeaders (Lio/sentry/ILogger;Ljava/lang/String;Ljava/util/List;Lio/sentry/SentryOptions;)Lio/sentry/PropagationContext;
+	public static fun fromHeaders (Lio/sentry/SentryTraceHeader;Lio/sentry/Baggage;Lio/sentry/SpanId;Lio/sentry/SentryOptions;)Lio/sentry/PropagationContext;
 	public fun getBaggage ()Lio/sentry/Baggage;
 	public fun getParentSpanId ()Lio/sentry/SpanId;
 	public fun getSampleRand ()Ljava/lang/Double;
@@ -3585,6 +3592,7 @@ public class io/sentry/SentryOptions {
 	public fun getDistribution ()Lio/sentry/SentryOptions$DistributionOptions;
 	public fun getDistributionController ()Lio/sentry/IDistributionApi;
 	public fun getDsn ()Ljava/lang/String;
+	public fun getEffectiveOrgId ()Ljava/lang/String;
 	public fun getEnvelopeDiskCache ()Lio/sentry/cache/IEnvelopeCache;
 	public fun getEnvelopeReader ()Lio/sentry/IEnvelopeReader;
 	public fun getEnvironment ()Ljava/lang/String;
@@ -3625,6 +3633,7 @@ public class io/sentry/SentryOptions {
 	public fun getOnOversizedEvent ()Lio/sentry/SentryOptions$OnOversizedEventCallback;
 	public fun getOpenTelemetryMode ()Lio/sentry/SentryOpenTelemetryMode;
 	public fun getOptionsObservers ()Ljava/util/List;
+	public fun getOrgId ()Ljava/lang/String;
 	public fun getOutboxPath ()Ljava/lang/String;
 	public fun getPerformanceCollectors ()Ljava/util/List;
 	public fun getProfileLifecycle ()Lio/sentry/ProfileLifecycle;
@@ -3697,6 +3706,7 @@ public class io/sentry/SentryOptions {
 	public fun isSendDefaultPii ()Z
 	public fun isSendModules ()Z
 	public fun isStartProfilerOnAppStart ()Z
+	public fun isStrictTraceContinuation ()Z
 	public fun isTraceOptionsRequests ()Z
 	public fun isTraceSampling ()Z
 	public fun isTracingEnabled ()Z
@@ -3781,6 +3791,7 @@ public class io/sentry/SentryOptions {
 	public fun setOnDiscard (Lio/sentry/SentryOptions$OnDiscardCallback;)V
 	public fun setOnOversizedEvent (Lio/sentry/SentryOptions$OnOversizedEventCallback;)V
 	public fun setOpenTelemetryMode (Lio/sentry/SentryOpenTelemetryMode;)V
+	public fun setOrgId (Ljava/lang/String;)V
 	public fun setPrintUncaughtStackTrace (Z)V
 	public fun setProfileLifecycle (Lio/sentry/ProfileLifecycle;)V
 	public fun setProfileSessionSampleRate (Ljava/lang/Double;)V
@@ -3813,6 +3824,7 @@ public class io/sentry/SentryOptions {
 	public fun setSpotlightConnectionUrl (Ljava/lang/String;)V
 	public fun setSslSocketFactory (Ljavax/net/ssl/SSLSocketFactory;)V
 	public fun setStartProfilerOnAppStart (Z)V
+	public fun setStrictTraceContinuation (Z)V
 	public fun setTag (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setThreadChecker (Lio/sentry/util/thread/IThreadChecker;)V
 	public fun setTraceOptionsRequests (Z)V
@@ -7800,6 +7812,7 @@ public final class io/sentry/util/TracingUtils {
 	public static fun isIgnored (Ljava/util/List;Ljava/lang/String;)Z
 	public static fun maybeUpdateBaggage (Lio/sentry/IScope;Lio/sentry/SentryOptions;)Lio/sentry/PropagationContext;
 	public static fun setTrace (Lio/sentry/IScopes;Lio/sentry/PropagationContext;)V
+	public static fun shouldContinueTrace (Lio/sentry/SentryOptions;Lio/sentry/Baggage;)Z
 	public static fun startNewTrace (Lio/sentry/IScopes;)V
 	public static fun trace (Lio/sentry/IScopes;Ljava/util/List;Lio/sentry/ISpan;)Lio/sentry/util/TracingUtils$TracingHeaders;
 	public static fun traceIfAllowed (Lio/sentry/IScopes;Ljava/lang/String;Ljava/util/List;Lio/sentry/ISpan;)Lio/sentry/util/TracingUtils$TracingHeaders;
diff --git a/sentry/src/main/java/io/sentry/Baggage.java b/sentry/src/main/java/io/sentry/Baggage.java
index 5f610a02918..4645df3f3a4 100644
--- a/sentry/src/main/java/io/sentry/Baggage.java
+++ b/sentry/src/main/java/io/sentry/Baggage.java
@@ -186,6 +186,7 @@ public static Baggage fromEvent(
     baggage.setPublicKey(options.retrieveParsedDsn().getPublicKey());
     baggage.setRelease(event.getRelease());
     baggage.setEnvironment(event.getEnvironment());
+    baggage.setOrgId(options.getEffectiveOrgId());
     baggage.setTransaction(transaction);
     // we don't persist sample rate
     baggage.setSampleRate(null);
@@ -450,6 +451,16 @@ public void setReplayId(final @Nullable String replayId) {
     set(DSCKeys.REPLAY_ID, replayId);
   }
 
+  @ApiStatus.Internal
+  public @Nullable String getOrgId() {
+    return get(DSCKeys.ORG_ID);
+  }
+
+  @ApiStatus.Internal
+  public void setOrgId(final @Nullable String orgId) {
+    set(DSCKeys.ORG_ID, orgId);
+  }
+
   /**
    * Sets / updates a value, but only if the baggage is still mutable.
    *
@@ -501,6 +512,7 @@ public void setValuesFromTransaction(
     if (replayId != null && !SentryId.EMPTY_ID.equals(replayId)) {
       setReplayId(replayId.toString());
     }
+    setOrgId(sentryOptions.getEffectiveOrgId());
     setSampleRate(sampleRate(samplingDecision));
     setSampled(StringUtils.toString(sampled(samplingDecision)));
     setSampleRand(sampleRand(samplingDecision));
@@ -536,6 +548,7 @@ public void setValuesFromScope(
     if (!SentryId.EMPTY_ID.equals(replayId)) {
       setReplayId(replayId.toString());
     }
+    setOrgId(options.getEffectiveOrgId());
     setTransaction(null);
     setSampleRate(null);
     setSampled(null);
@@ -632,6 +645,7 @@ public static final class DSCKeys {
     public static final String SAMPLE_RAND = "sentry-sample_rand";
     public static final String SAMPLED = "sentry-sampled";
     public static final String REPLAY_ID = "sentry-replay_id";
+    public static final String ORG_ID = "sentry-org_id";
 
     public static final List<String> ALL =
         Arrays.asList(
@@ -644,6 +658,7 @@ public static final class DSCKeys {
             SAMPLE_RATE,
             SAMPLE_RAND,
             SAMPLED,
-            REPLAY_ID);
+            REPLAY_ID,
+            ORG_ID);
   }
 }
diff --git a/sentry/src/main/java/io/sentry/Dsn.java b/sentry/src/main/java/io/sentry/Dsn.java
index 705d383266e..0d21499b5fc 100644
--- a/sentry/src/main/java/io/sentry/Dsn.java
+++ b/sentry/src/main/java/io/sentry/Dsn.java
@@ -2,15 +2,20 @@
 
 import io.sentry.util.Objects;
 import java.net.URI;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 final class Dsn {
+  private static final @NotNull Pattern ORG_ID_PATTERN = Pattern.compile("^o(\\d+)\\.");
+
   private final @NotNull String projectId;
   private final @Nullable String path;
   private final @Nullable String secretKey;
   private final @NotNull String publicKey;
   private final @NotNull URI sentryUri;
+  private final @Nullable String orgId;
 
   /*
   / The project ID which the authenticated user is bound to.
@@ -87,8 +92,23 @@ URI getSentryUri() {
       sentryUri =
           new URI(
               scheme, null, uri.getHost(), uri.getPort(), path + "api/" + projectId, null, null);
+
+      // Extract org ID from host (e.g., "o123.ingest.sentry.io" -> "123")
+      String extractedOrgId = null;
+      final String host = uri.getHost();
+      if (host != null) {
+        final Matcher matcher = ORG_ID_PATTERN.matcher(host);
+        if (matcher.find()) {
+          extractedOrgId = matcher.group(1);
+        }
+      }
+      orgId = extractedOrgId;
     } catch (Throwable e) {
       throw new IllegalArgumentException(e);
     }
   }
+
+  public @Nullable String getOrgId() {
+    return orgId;
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/ExternalOptions.java b/sentry/src/main/java/io/sentry/ExternalOptions.java
index dade1f140c8..e992c04466b 100644
--- a/sentry/src/main/java/io/sentry/ExternalOptions.java
+++ b/sentry/src/main/java/io/sentry/ExternalOptions.java
@@ -66,6 +66,9 @@ public final class ExternalOptions {
   private @Nullable String profilingTracesDirPath;
   private @Nullable ProfileLifecycle profileLifecycle;
 
+  private @Nullable Boolean strictTraceContinuation;
+  private @Nullable String orgId;
+
   private @Nullable SentryOptions.Cron cron;
 
   @SuppressWarnings("unchecked")
@@ -221,6 +224,10 @@ public final class ExternalOptions {
       options.setCron(cron);
     }
 
+    options.setStrictTraceContinuation(
+        propertiesProvider.getBooleanProperty("enable-strict-trace-continuation"));
+    options.setOrgId(propertiesProvider.getProperty("org-id"));
+
     options.setEnableSpotlight(propertiesProvider.getBooleanProperty("enable-spotlight"));
     options.setSpotlightConnectionUrl(propertiesProvider.getProperty("spotlight-connection-url"));
     options.setProfileSessionSampleRate(
@@ -621,6 +628,22 @@ public void setProfilingTracesDirPath(@Nullable String profilingTracesDirPath) {
     this.profilingTracesDirPath = profilingTracesDirPath;
   }
 
+  public @Nullable Boolean isStrictTraceContinuation() {
+    return strictTraceContinuation;
+  }
+
+  public void setStrictTraceContinuation(final @Nullable Boolean strictTraceContinuation) {
+    this.strictTraceContinuation = strictTraceContinuation;
+  }
+
+  public @Nullable String getOrgId() {
+    return orgId;
+  }
+
+  public void setOrgId(final @Nullable String orgId) {
+    this.orgId = orgId;
+  }
+
   public @Nullable ProfileLifecycle getProfileLifecycle() {
     return profileLifecycle;
   }
diff --git a/sentry/src/main/java/io/sentry/PropagationContext.java b/sentry/src/main/java/io/sentry/PropagationContext.java
index e7d39d35fe5..a6779805276 100644
--- a/sentry/src/main/java/io/sentry/PropagationContext.java
+++ b/sentry/src/main/java/io/sentry/PropagationContext.java
@@ -15,14 +15,16 @@ public final class PropagationContext {
   public static PropagationContext fromHeaders(
       final @NotNull ILogger logger,
       final @Nullable String sentryTraceHeader,
-      final @Nullable String baggageHeader) {
-    return fromHeaders(logger, sentryTraceHeader, Arrays.asList(baggageHeader));
+      final @Nullable String baggageHeader,
+      final @Nullable SentryOptions options) {
+    return fromHeaders(logger, sentryTraceHeader, Arrays.asList(baggageHeader), options);
   }
 
   public static @NotNull PropagationContext fromHeaders(
       final @NotNull ILogger logger,
       final @Nullable String sentryTraceHeaderString,
-      final @Nullable List<String> baggageHeaderStrings) {
+      final @Nullable List<String> baggageHeaderStrings,
+      final @Nullable SentryOptions options) {
     if (sentryTraceHeaderString == null) {
       return new PropagationContext();
     }
@@ -30,7 +32,8 @@ public static PropagationContext fromHeaders(
     try {
       final @NotNull SentryTraceHeader traceHeader = new SentryTraceHeader(sentryTraceHeaderString);
       final @NotNull Baggage baggage = Baggage.fromHeader(baggageHeaderStrings, logger);
-      return fromHeaders(traceHeader, baggage, null);
+
+      return fromHeaders(traceHeader, baggage, null, options);
     } catch (InvalidSentryTraceHeaderException e) {
       logger.log(SentryLevel.DEBUG, e, "Failed to parse Sentry trace header: %s", e.getMessage());
       return new PropagationContext();
@@ -40,7 +43,15 @@ public static PropagationContext fromHeaders(
   public static @NotNull PropagationContext fromHeaders(
       final @NotNull SentryTraceHeader sentryTraceHeader,
       final @Nullable Baggage baggage,
-      final @Nullable SpanId spanId) {
+      final @Nullable SpanId spanId,
+      final @Nullable SentryOptions options) {
+    if (options != null && !TracingUtils.shouldContinueTrace(options, baggage)) {
+      options
+          .getLogger()
+          .log(SentryLevel.DEBUG, "Not continuing trace due to strict org ID validation failure.");
+      return new PropagationContext();
+    }
+
     final @NotNull SpanId spanIdToUse = spanId == null ? new SpanId() : spanId;
 
     return new PropagationContext(
diff --git a/sentry/src/main/java/io/sentry/Scopes.java b/sentry/src/main/java/io/sentry/Scopes.java
index e155979e064..82c03feac4b 100644
--- a/sentry/src/main/java/io/sentry/Scopes.java
+++ b/sentry/src/main/java/io/sentry/Scopes.java
@@ -1135,7 +1135,8 @@ public void reportFullyDisplayed() {
       final @Nullable String sentryTrace, final @Nullable List<String> baggageHeaders) {
     @NotNull
     PropagationContext propagationContext =
-        PropagationContext.fromHeaders(getOptions().getLogger(), sentryTrace, baggageHeaders);
+        PropagationContext.fromHeaders(
+            getOptions().getLogger(), sentryTrace, baggageHeaders, getOptions());
     configureScope(
         (scope) -> {
           scope.withPropagationContext(
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 9df125b4d11..86086f8816b 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -432,6 +432,21 @@ public class SentryOptions {
   /** Whether to propagate W3C traceparent HTTP header. */
   private boolean propagateTraceparent = false;
 
+  /**
+   * Controls whether the SDK requires matching org IDs from incoming baggage to continue a trace.
+   * When true, both the SDK's org ID and the incoming baggage org ID must be present and match.
+   * When false, a mismatch between present org IDs will still start a new trace, but missing org
+   * IDs on either side are tolerated.
+   */
+  private boolean strictTraceContinuation = false;
+
+  /**
+   * An optional organization ID. The SDK will try to extract it from the DSN in most cases but you
+   * can provide it explicitly for self-hosted and Relay setups. This value is used for trace
+   * propagation and for features like {@link #strictTraceContinuation}.
+   */
+  private @Nullable String orgId;
+
   /** Proguard UUID. */
   private @Nullable String proguardUuid;
 
@@ -2306,6 +2321,42 @@ public void setPropagateTraceparent(final boolean propagateTraceparent) {
     this.propagateTraceparent = propagateTraceparent;
   }
 
+  public boolean isStrictTraceContinuation() {
+    return strictTraceContinuation;
+  }
+
+  public void setStrictTraceContinuation(final boolean strictTraceContinuation) {
+    this.strictTraceContinuation = strictTraceContinuation;
+  }
+
+  public @Nullable String getOrgId() {
+    return orgId;
+  }
+
+  public void setOrgId(final @Nullable String orgId) {
+    this.orgId = orgId;
+  }
+
+  /**
+   * Returns the effective org ID, preferring the explicit config option over the DSN-parsed value.
+   * Empty or whitespace-only explicit org IDs are treated as unset and fall back to the DSN.
+   */
+  @ApiStatus.Internal
+  public @Nullable String getEffectiveOrgId() {
+    if (orgId != null) {
+      final @NotNull String trimmed = orgId.trim();
+      if (!trimmed.isEmpty()) {
+        return trimmed;
+      }
+    }
+    try {
+      final @Nullable String dsnOrgId = retrieveParsedDsn().getOrgId();
+      return dsnOrgId;
+    } catch (Throwable e) {
+      return null;
+    }
+  }
+
   /**
    * Returns a Proguard UUID.
    *
@@ -3557,6 +3608,12 @@ public void merge(final @NotNull ExternalOptions options) {
     if (options.getProfileLifecycle() != null) {
       setProfileLifecycle(options.getProfileLifecycle());
     }
+    if (options.isStrictTraceContinuation() != null) {
+      setStrictTraceContinuation(options.isStrictTraceContinuation());
+    }
+    if (options.getOrgId() != null) {
+      setOrgId(options.getOrgId());
+    }
   }
 
   private @NotNull SdkVersion createSdkVersion() {
diff --git a/sentry/src/main/java/io/sentry/util/TracingUtils.java b/sentry/src/main/java/io/sentry/util/TracingUtils.java
index 673980e7359..9de7adec4be 100644
--- a/sentry/src/main/java/io/sentry/util/TracingUtils.java
+++ b/sentry/src/main/java/io/sentry/util/TracingUtils.java
@@ -196,6 +196,32 @@ public static boolean isIgnored(
     return false;
   }
 
+  @ApiStatus.Internal
+  public static boolean shouldContinueTrace(
+      final @NotNull SentryOptions options, final @Nullable Baggage baggage) {
+    final @Nullable String sdkOrgId = options.getEffectiveOrgId();
+    final @Nullable String rawBaggageOrgId = baggage != null ? baggage.getOrgId() : null;
+    final @Nullable String baggageOrgId =
+        (rawBaggageOrgId != null && !rawBaggageOrgId.trim().isEmpty())
+            ? rawBaggageOrgId.trim()
+            : null;
+
+    // Mismatched org IDs always reject regardless of strict mode
+    if (sdkOrgId != null && baggageOrgId != null && !sdkOrgId.equals(baggageOrgId)) {
+      return false;
+    }
+
+    // In strict mode, both must be present and match (unless both are missing)
+    if (options.isStrictTraceContinuation()) {
+      if (sdkOrgId == null && baggageOrgId == null) {
+        return true;
+      }
+      return sdkOrgId != null && sdkOrgId.equals(baggageOrgId);
+    }
+
+    return true;
+  }
+
   /**
    * Ensures a non null baggage instance is present by creating a new Baggage instance if null is
    * passed in.
diff --git a/sentry/src/test/java/io/sentry/BaggageTest.kt b/sentry/src/test/java/io/sentry/BaggageTest.kt
index fd187c61982..e177645734d 100644
--- a/sentry/src/test/java/io/sentry/BaggageTest.kt
+++ b/sentry/src/test/java/io/sentry/BaggageTest.kt
@@ -4,6 +4,7 @@ import com.github.javafaker.Faker
 import io.sentry.Baggage.MAX_BAGGAGE_LIST_MEMBER_COUNT
 import io.sentry.Baggage.MAX_BAGGAGE_STRING_LENGTH
 import io.sentry.protocol.SentryId
+import io.sentry.protocol.TransactionNameSource
 import java.util.UUID
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -736,6 +737,90 @@ class BaggageTest {
     assertNull(baggage.sampleRate)
   }
 
+  @Test
+  fun `setValuesFromScope falls back to DSN org id when explicit orgId is empty`() {
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@o123.ingest.sentry.io/456"
+        orgId = ""
+      }
+    val scope = Scope(options)
+    val baggage = Baggage(logger)
+
+    baggage.setValuesFromScope(scope, options)
+
+    assertEquals("123", baggage.orgId)
+  }
+
+  @Test
+  fun `setValuesFromScope falls back to DSN org id when explicit orgId is whitespace`() {
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@o123.ingest.sentry.io/456"
+        orgId = "   "
+      }
+    val scope = Scope(options)
+    val baggage = Baggage(logger)
+
+    baggage.setValuesFromScope(scope, options)
+
+    assertEquals("123", baggage.orgId)
+  }
+
+  @Test
+  fun `setValuesFromTransaction falls back to DSN org id when explicit orgId is empty`() {
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@o123.ingest.sentry.io/456"
+        orgId = ""
+      }
+    val baggage = Baggage(logger)
+
+    baggage.setValuesFromTransaction(
+      SentryId(),
+      SentryId(),
+      options,
+      TracesSamplingDecision(true, 1.0),
+      "test-transaction",
+      TransactionNameSource.CUSTOM,
+    )
+
+    assertEquals("123", baggage.orgId)
+  }
+
+  @Test
+  fun `fromEvent falls back to DSN org id when explicit orgId is empty`() {
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@o123.ingest.sentry.io/456"
+        orgId = ""
+      }
+    val event = SentryEvent()
+    event.contexts.setTrace(SpanContext("test-op"))
+
+    val baggage = Baggage.fromEvent(event, "test-transaction", options)
+
+    assertEquals("123", baggage.orgId)
+  }
+
+  @Test
+  fun `baggage header does not include org id when both explicit and DSN org ids are empty`() {
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/456"
+        orgId = ""
+        release = "1.0.0"
+      }
+    val scope = Scope(options)
+    val baggage = Baggage(logger)
+
+    baggage.setValuesFromScope(scope, options)
+    val headerString = baggage.toHeaderString(null)
+
+    // Should not contain sentry-org_id if both explicit and DSN org ids are null/empty
+    assertFalse(headerString.contains("sentry-org_id"))
+  }
+
   /**
    * token = 1*tchar tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." / "^" / "_" /
    * "`" / "|" / "~" / DIGIT / ALPHA ; any VCHAR, except delimiters
diff --git a/sentry/src/test/java/io/sentry/DsnTest.kt b/sentry/src/test/java/io/sentry/DsnTest.kt
index 6c454ad5c75..7e2982073f1 100644
--- a/sentry/src/test/java/io/sentry/DsnTest.kt
+++ b/sentry/src/test/java/io/sentry/DsnTest.kt
@@ -121,4 +121,28 @@ class DsnTest {
     Dsn("HTTP://publicKey:secretKey@host/path/id")
     Dsn("HTTPS://publicKey:secretKey@host/path/id")
   }
+
+  @Test
+  fun `extracts org id from host`() {
+    val dsn = Dsn("https://key@o123.ingest.sentry.io/456")
+    assertEquals("123", dsn.orgId)
+  }
+
+  @Test
+  fun `extracts single digit org id from host`() {
+    val dsn = Dsn("https://key@o1.ingest.us.sentry.io/456")
+    assertEquals("1", dsn.orgId)
+  }
+
+  @Test
+  fun `returns null org id when host has no org prefix`() {
+    val dsn = Dsn("https://key@sentry.io/456")
+    assertNull(dsn.orgId)
+  }
+
+  @Test
+  fun `returns null org id for non-standard host`() {
+    val dsn = Dsn("http://key@localhost:9000/456")
+    assertNull(dsn.orgId)
+  }
 }
diff --git a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
index 298eff34ba0..54630355557 100644
--- a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
@@ -463,6 +463,35 @@ class ExternalOptionsTest {
     }
   }
 
+  @Test
+  fun `creates options with strictTraceContinuation set to true`() {
+    withPropertiesFile("enable-strict-trace-continuation=true") { options ->
+      assertTrue(options.isStrictTraceContinuation == true)
+    }
+  }
+
+  @Test
+  fun `creates options with strictTraceContinuation set to false`() {
+    withPropertiesFile("enable-strict-trace-continuation=false") { options ->
+      assertTrue(options.isStrictTraceContinuation == false)
+    }
+  }
+
+  @Test
+  fun `creates options with strictTraceContinuation set to null when not set`() {
+    withPropertiesFile { assertNull(it.isStrictTraceContinuation) }
+  }
+
+  @Test
+  fun `creates options with orgId using external properties`() {
+    withPropertiesFile("org-id=12345") { options -> assertEquals("12345", options.orgId) }
+  }
+
+  @Test
+  fun `creates options with orgId set to null when not set`() {
+    withPropertiesFile { assertNull(it.orgId) }
+  }
+
   private fun withPropertiesFile(
     textLines: List<String> = emptyList(),
     logger: ILogger = mock(),
diff --git a/sentry/src/test/java/io/sentry/PropagationContextTest.kt b/sentry/src/test/java/io/sentry/PropagationContextTest.kt
index 8e83dec4deb..5e38846519d 100644
--- a/sentry/src/test/java/io/sentry/PropagationContextTest.kt
+++ b/sentry/src/test/java/io/sentry/PropagationContextTest.kt
@@ -1,7 +1,9 @@
 package io.sentry
 
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertNotEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
@@ -13,6 +15,7 @@ class PropagationContextTest {
         NoOpLogger.getInstance(),
         "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1",
         "sentry-trace_id=a,sentry-transaction=sentryTransaction",
+        null,
       )
     assertFalse(propagationContext.baggage.isMutable)
     assertTrue(propagationContext.baggage.isShouldFreeze)
@@ -25,6 +28,7 @@ class PropagationContextTest {
         NoOpLogger.getInstance(),
         "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1",
         "a=b",
+        null,
       )
     assertTrue(propagationContext.baggage.isMutable)
     assertFalse(propagationContext.baggage.isShouldFreeze)
@@ -37,9 +41,169 @@ class PropagationContextTest {
         NoOpLogger.getInstance(),
         "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1",
         null as? String?,
+        null,
       )
     assertNotNull(propagationContext.baggage)
     assertTrue(propagationContext.baggage.isMutable)
     assertFalse(propagationContext.baggage.isShouldFreeze)
   }
+
+  // Decision matrix tests for shouldContinueTrace
+
+  private val incomingTraceId = "bc6d53f15eb88f4320054569b8c553d4"
+  private val sentryTrace = "bc6d53f15eb88f4320054569b8c553d4-b72fa28504b07285-1"
+
+  private fun makeOptions(
+    dsnOrgId: String?,
+    explicitOrgId: String? = null,
+    strict: Boolean = false,
+  ): SentryOptions {
+    val options = SentryOptions()
+    if (dsnOrgId != null) {
+      options.dsn = "https://key@o$dsnOrgId.ingest.sentry.io/123"
+    } else {
+      options.dsn = "https://key@sentry.io/123"
+    }
+    options.orgId = explicitOrgId
+    options.isStrictTraceContinuation = strict
+    return options
+  }
+
+  private fun makeBaggage(orgId: String?): String {
+    val parts = mutableListOf("sentry-trace_id=$incomingTraceId")
+    if (orgId != null) {
+      parts.add("sentry-org_id=$orgId")
+    }
+    return parts.joinToString(",")
+  }
+
+  @Test
+  fun `strict=false, matching orgs - continues trace`() {
+    val options = makeOptions(dsnOrgId = "1", strict = false)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage("1")),
+        options,
+      )
+    assertEquals(incomingTraceId, pc.traceId.toString())
+  }
+
+  @Test
+  fun `strict=false, baggage missing org - continues trace`() {
+    val options = makeOptions(dsnOrgId = "1", strict = false)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage(null)),
+        options,
+      )
+    assertEquals(incomingTraceId, pc.traceId.toString())
+  }
+
+  @Test
+  fun `strict=false, sdk missing org - continues trace`() {
+    val options = makeOptions(dsnOrgId = null, strict = false)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage("1")),
+        options,
+      )
+    assertEquals(incomingTraceId, pc.traceId.toString())
+  }
+
+  @Test
+  fun `strict=false, both missing org - continues trace`() {
+    val options = makeOptions(dsnOrgId = null, strict = false)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage(null)),
+        options,
+      )
+    assertEquals(incomingTraceId, pc.traceId.toString())
+  }
+
+  @Test
+  fun `strict=false, mismatched orgs - starts new trace`() {
+    val options = makeOptions(dsnOrgId = "2", strict = false)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage("1")),
+        options,
+      )
+    assertNotEquals(incomingTraceId, pc.traceId.toString())
+  }
+
+  @Test
+  fun `strict=true, matching orgs - continues trace`() {
+    val options = makeOptions(dsnOrgId = "1", strict = true)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage("1")),
+        options,
+      )
+    assertEquals(incomingTraceId, pc.traceId.toString())
+  }
+
+  @Test
+  fun `strict=true, baggage missing org - starts new trace`() {
+    val options = makeOptions(dsnOrgId = "1", strict = true)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage(null)),
+        options,
+      )
+    assertNotEquals(incomingTraceId, pc.traceId.toString())
+  }
+
+  @Test
+  fun `strict=true, sdk missing org - starts new trace`() {
+    val options = makeOptions(dsnOrgId = null, strict = true)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage("1")),
+        options,
+      )
+    assertNotEquals(incomingTraceId, pc.traceId.toString())
+  }
+
+  @Test
+  fun `strict=true, both missing org - continues trace`() {
+    val options = makeOptions(dsnOrgId = null, strict = true)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage(null)),
+        options,
+      )
+    assertEquals(incomingTraceId, pc.traceId.toString())
+  }
+
+  @Test
+  fun `strict=true, mismatched orgs - starts new trace`() {
+    val options = makeOptions(dsnOrgId = "2", strict = true)
+    val pc =
+      PropagationContext.fromHeaders(
+        NoOpLogger.getInstance(),
+        sentryTrace,
+        listOf(makeBaggage("1")),
+        options,
+      )
+    assertNotEquals(incomingTraceId, pc.traceId.toString())
+  }
 }
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index 1b9ce5eace3..da014b30f74 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -972,6 +972,114 @@ class SentryOptionsTest {
     assertSame(mock, options.logs.loggerBatchProcessorFactory)
   }
 
+  @Test
+  fun `when options is initialized, strictTraceContinuation is false`() {
+    assertFalse(SentryOptions().isStrictTraceContinuation)
+  }
+
+  @Test
+  fun `when options is initialized, orgId is null`() {
+    assertNull(SentryOptions().orgId)
+  }
+
+  @Test
+  fun `merging options applies strictTraceContinuation`() {
+    val externalOptions = ExternalOptions()
+    externalOptions.setStrictTraceContinuation(true)
+    val options = SentryOptions()
+    options.merge(externalOptions)
+    assertTrue(options.isStrictTraceContinuation)
+  }
+
+  @Test
+  fun `merging options when strictTraceContinuation is not set preserves the previous value`() {
+    val externalOptions = ExternalOptions()
+    val options = SentryOptions()
+    options.isStrictTraceContinuation = true
+    options.merge(externalOptions)
+    assertTrue(options.isStrictTraceContinuation)
+  }
+
+  @Test
+  fun `merging options applies orgId`() {
+    val externalOptions = ExternalOptions()
+    externalOptions.setOrgId("12345")
+    val options = SentryOptions()
+    options.merge(externalOptions)
+    assertEquals("12345", options.orgId)
+  }
+
+  @Test
+  fun `merging options when orgId is not set preserves the previous value`() {
+    val externalOptions = ExternalOptions()
+    val options = SentryOptions()
+    options.orgId = "original"
+    options.merge(externalOptions)
+    assertEquals("original", options.orgId)
+  }
+
+  @Test
+  fun `getEffectiveOrgId prefers explicit orgId over DSN`() {
+    val options = SentryOptions()
+    options.dsn = "https://key@o123.ingest.sentry.io/456"
+    options.orgId = "999"
+    assertEquals("999", options.effectiveOrgId)
+  }
+
+  @Test
+  fun `getEffectiveOrgId falls back to DSN org id`() {
+    val options = SentryOptions()
+    options.dsn = "https://key@o123.ingest.sentry.io/456"
+    assertEquals("123", options.effectiveOrgId)
+  }
+
+  @Test
+  fun `getEffectiveOrgId returns null when no orgId configured`() {
+    val options = SentryOptions()
+    options.dsn = "https://key@sentry.io/456"
+    assertNull(options.effectiveOrgId)
+  }
+
+  @Test
+  fun `getEffectiveOrgId falls back to DSN when explicit orgId is empty string`() {
+    val options = SentryOptions()
+    options.dsn = "https://key@o123.ingest.sentry.io/456"
+    options.orgId = ""
+    assertEquals("123", options.effectiveOrgId)
+  }
+
+  @Test
+  fun `getEffectiveOrgId falls back to DSN when explicit orgId is whitespace only`() {
+    val options = SentryOptions()
+    options.dsn = "https://key@o123.ingest.sentry.io/456"
+    options.orgId = "   "
+    assertEquals("123", options.effectiveOrgId)
+  }
+
+  @Test
+  fun `getEffectiveOrgId falls back to DSN when explicit orgId is tab and newline`() {
+    val options = SentryOptions()
+    options.dsn = "https://key@o123.ingest.sentry.io/456"
+    options.orgId = "\t\n"
+    assertEquals("123", options.effectiveOrgId)
+  }
+
+  @Test
+  fun `getEffectiveOrgId returns null when explicit orgId is empty and no DSN orgId`() {
+    val options = SentryOptions()
+    options.dsn = "https://key@sentry.io/456"
+    options.orgId = ""
+    assertNull(options.effectiveOrgId)
+  }
+
+  @Test
+  fun `getEffectiveOrgId trims whitespace from explicit orgId`() {
+    val options = SentryOptions()
+    options.dsn = "https://key@o123.ingest.sentry.io/456"
+    options.orgId = "  999  "
+    assertEquals("999", options.effectiveOrgId)
+  }
+
   @Test
   fun `scopesStorageFactory is null by default`() {
     val options = SentryOptions()
diff --git a/sentry/src/test/java/io/sentry/TransactionContextTest.kt b/sentry/src/test/java/io/sentry/TransactionContextTest.kt
index a27a600e96c..55603853a66 100644
--- a/sentry/src/test/java/io/sentry/TransactionContextTest.kt
+++ b/sentry/src/test/java/io/sentry/TransactionContextTest.kt
@@ -31,6 +31,7 @@ class TransactionContextTest {
         logger,
         SentryTraceHeader(SentryId(), SpanId(), false).value,
         "sentry-trace_id=a,sentry-transaction=sentryTransaction,sentry-sample_rate=0.3",
+        null,
       )
     val context = TransactionContext.fromPropagationContext(propagationContext)
     assertNull(context.sampled)
@@ -48,6 +49,7 @@ class TransactionContextTest {
         logger,
         SentryTraceHeader(SentryId(), SpanId(), false).value,
         "sentry-trace_id=a,sentry-transaction=sentryTransaction",
+        null,
       )
     val context = TransactionContext.fromPropagationContext(propagationContext)
     assertNull(context.sampled)
@@ -65,6 +67,7 @@ class TransactionContextTest {
         logger,
         SentryTraceHeader(SentryId(), SpanId(), true).value,
         "sentry-trace_id=a,sentry-transaction=sentryTransaction,sentry-sample_rate=0.3",
+        null,
       )
     val context = TransactionContext.fromPropagationContext(propagationContext)
     assertNull(context.sampled)
@@ -82,6 +85,7 @@ class TransactionContextTest {
         logger,
         SentryTraceHeader(SentryId(), SpanId(), true).value,
         "sentry-trace_id=a,sentry-transaction=sentryTransaction",
+        null,
       )
     val context = TransactionContext.fromPropagationContext(propagationContext)
     assertNull(context.sampled)
diff --git a/sentry/src/test/java/io/sentry/util/TracingUtilsTest.kt b/sentry/src/test/java/io/sentry/util/TracingUtilsTest.kt
index 9c906712261..edfcc361b08 100644
--- a/sentry/src/test/java/io/sentry/util/TracingUtilsTest.kt
+++ b/sentry/src/test/java/io/sentry/util/TracingUtilsTest.kt
@@ -510,4 +510,84 @@ class TracingUtilsTest {
     assertEquals(fixture.scope.propagationContext.spanId.toString(), parts[2])
     assertEquals("00", parts[3])
   }
+
+  private fun makeOptions(
+    dsnOrgId: String?,
+    explicitOrgId: String? = null,
+    strict: Boolean = false,
+  ): SentryOptions {
+    val options = SentryOptions()
+    if (dsnOrgId != null) {
+      options.dsn = "https://key@o$dsnOrgId.ingest.sentry.io/123"
+    } else {
+      options.dsn = "https://key@sentry.io/123"
+    }
+    options.orgId = explicitOrgId
+    options.isStrictTraceContinuation = strict
+    return options
+  }
+
+  private fun makeBaggage(orgId: String?): Baggage {
+    val raw =
+      if (orgId != null) {
+        "sentry-trace_id=bc6d53f15eb88f4320054569b8c553d4,sentry-org_id=$orgId"
+      } else {
+        "sentry-trace_id=bc6d53f15eb88f4320054569b8c553d4"
+      }
+    return Baggage.fromHeader(raw, NoOpLogger.getInstance())
+  }
+
+  @Test
+  fun `shouldContinueTrace strict=false matching org ids returns true`() {
+    val options = makeOptions(dsnOrgId = "1", strict = false)
+    assertTrue(TracingUtils.shouldContinueTrace(options, makeBaggage("1")))
+  }
+
+  @Test
+  fun `shouldContinueTrace strict=false mismatched org ids returns false`() {
+    val options = makeOptions(dsnOrgId = "2", strict = false)
+    assertFalse(TracingUtils.shouldContinueTrace(options, makeBaggage("1")))
+  }
+
+  @Test
+  fun `shouldContinueTrace strict=true matching org ids returns true`() {
+    val options = makeOptions(dsnOrgId = "1", strict = true)
+    assertTrue(TracingUtils.shouldContinueTrace(options, makeBaggage("1")))
+  }
+
+  @Test
+  fun `shouldContinueTrace strict=true missing baggage org id returns false`() {
+    val options = makeOptions(dsnOrgId = "1", strict = true)
+    assertFalse(TracingUtils.shouldContinueTrace(options, makeBaggage(null)))
+  }
+
+  @Test
+  fun `shouldContinueTrace strict=true both missing org ids returns true`() {
+    val options = makeOptions(dsnOrgId = null, strict = true)
+    assertTrue(TracingUtils.shouldContinueTrace(options, makeBaggage(null)))
+  }
+
+  @Test
+  fun `shouldContinueTrace uses DSN fallback when explicit orgId is empty`() {
+    val options = makeOptions(dsnOrgId = "123", explicitOrgId = "", strict = true)
+    assertTrue(TracingUtils.shouldContinueTrace(options, makeBaggage("123")))
+  }
+
+  @Test
+  fun `shouldContinueTrace uses DSN fallback when explicit orgId is whitespace`() {
+    val options = makeOptions(dsnOrgId = "123", explicitOrgId = "   ", strict = true)
+    assertTrue(TracingUtils.shouldContinueTrace(options, makeBaggage("123")))
+  }
+
+  @Test
+  fun `shouldContinueTrace rejects mismatch after empty explicit orgId falls back to DSN`() {
+    val options = makeOptions(dsnOrgId = "123", explicitOrgId = "", strict = true)
+    assertFalse(TracingUtils.shouldContinueTrace(options, makeBaggage("999")))
+  }
+
+  @Test
+  fun `shouldContinueTrace strict=false with empty explicit orgId uses DSN fallback`() {
+    val options = makeOptions(dsnOrgId = "123", explicitOrgId = "", strict = false)
+    assertTrue(TracingUtils.shouldContinueTrace(options, makeBaggage("123")))
+  }
 }

From 58892596dfba8c72800e3a5bc3257b0693ca6211 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 31 Mar 2026 15:15:06 +0200
Subject: [PATCH 086/391] build(deps): bump github/codeql-action from 4.32.6 to
 4.35.1 (#5243)

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.32.6 to 4.35.1.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/0d579ffd059c29b07949a3cce3983f0780820c98...c10b8064de6f491fea524254123dbe5e09572f13)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-version: 4.35.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql-analysis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 06aa7fdcba4..6b30f064c49 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@0d579ffd059c29b07949a3cce3983f0780820c98 # pin@v2
+        uses: github/codeql-action/init@c10b8064de6f491fea524254123dbe5e09572f13 # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@0d579ffd059c29b07949a3cce3983f0780820c98 # pin@v2
+        uses: github/codeql-action/analyze@c10b8064de6f491fea524254123dbe5e09572f13 # pin@v2

From d12a33cb0d775be364de874512cee8fa431b110e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 31 Mar 2026 15:18:29 +0200
Subject: [PATCH 087/391] build(deps): bump requests from 2.32.4 to 2.33.0 in
 the uv group across 1 directory (#5237)

Bumps the uv group with 1 update in the / directory: [requests](https://github.com/psf/requests).


Updates `requests` from 2.32.4 to 2.33.0
- [Release notes](https://github.com/psf/requests/releases)
- [Changelog](https://github.com/psf/requests/blob/main/HISTORY.md)
- [Commits](https://github.com/psf/requests/compare/v2.32.4...v2.33.0)

---
updated-dependencies:
- dependency-name: requests
  dependency-version: 2.33.0
  dependency-type: direct:production
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index ce11ab2364c..ace4a3e0374 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,5 @@
 certifi==2025.7.14
 charset-normalizer==3.4.2
 idna==3.10
-requests==2.32.4
+requests==2.33.0
 urllib3==2.6.3

From 34e1ee33c2967e77d7fafe5c698bb84eb8de22fb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 31 Mar 2026 15:47:15 +0200
Subject: [PATCH 088/391] build(deps): bump getsentry/craft from 2.24.1 to
 2.25.2 (#5242)

Bumps [getsentry/craft](https://github.com/getsentry/craft) from 2.24.1 to 2.25.2.
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/013a7b2113c2cac0ff32d5180cfeaefc7c9ce5b6...ba01e596c4a4c07692f0de10b0d4fe05f3dd0292)

---
updated-dependencies:
- dependency-name: getsentry/craft
  dependency-version: 2.25.2
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index cdf7c141026..eb99dca7f25 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@013a7b2113c2cac0ff32d5180cfeaefc7c9ce5b6 # v2
+        uses: getsentry/craft@ba01e596c4a4c07692f0de10b0d4fe05f3dd0292 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From a0e1341f423af62c9a7b1c02ff251103a42a0d26 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 31 Mar 2026 15:48:36 +0200
Subject: [PATCH 089/391] build(deps): bump
 getsentry/craft/.github/workflows/changelog-preview.yml from 2.25.0 to 2.25.2
 (#5245)

Bumps [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) from 2.25.0 to 2.25.2.
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/f4889d04564e47311038ecb6b910fef6b6cf1363...ba01e596c4a4c07692f0de10b0d4fe05f3dd0292)

---
updated-dependencies:
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.25.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/changelog-preview.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index 2b37e202856..f22a34cba7c 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@f4889d04564e47311038ecb6b910fef6b6cf1363 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@ba01e596c4a4c07692f0de10b0d4fe05f3dd0292 # v2
     secrets: inherit

From 05d6f765f5e3cb32d2d12e234612a64c3e651d99 Mon Sep 17 00:00:00 2001
From: Itay Brenner <itaybrenner@hotmail.com>
Date: Tue, 31 Mar 2026 11:22:08 -0300
Subject: [PATCH 090/391] chore: bump action-app-sdk-overhead-metrics SHA
 (#5238)

---
 .github/workflows/integration-tests-benchmarks.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index dec5c8eae51..dee3ddb6652 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -106,7 +106,7 @@ jobs:
         run: ./gradlew :sentry-android-integration-tests:test-app-sentry:assembleRelease
 
       - name: Collect app metrics
-        uses: getsentry/action-app-sdk-overhead-metrics@ecce2e2718b6d97ad62220fca05627900b061ed5
+        uses: getsentry/action-app-sdk-overhead-metrics@44fb5489ac4ac252c87d84811972dc93a1e490b8
         with:
           config: sentry-android-integration-tests/metrics-test.yml
           sauce-user: ${{ secrets.SAUCE_USERNAME }}

From a1eadfac15bc28deb016dfb5632b483770eedc4e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 31 Mar 2026 16:23:10 +0200
Subject: [PATCH 091/391] build(deps): bump codecov/codecov-action from 5.5.2
 to 6.0.0 (#5246)

Bumps [codecov/codecov-action](https://github.com/codecov/codecov-action) from 5.5.2 to 6.0.0.
- [Release notes](https://github.com/codecov/codecov-action/releases)
- [Changelog](https://github.com/codecov/codecov-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/codecov/codecov-action/compare/671740ac38dd9b0130fbe1cec585b89eea48d3de...57e3a136b779b570ffcdbf80b3bdc90e7fab3de2)

---
updated-dependencies:
- dependency-name: codecov/codecov-action
  dependency-version: 6.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 3e5a79f5930..06fa061d4ac 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -45,7 +45,7 @@ jobs:
         run: make preMerge
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # pin@v4
+        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # pin@v4
         with:
           name: sentry-java
           fail_ci_if_error: false

From 62c14b0aad97f2aa44e02c0ad881c237c2252e1b Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Wed, 1 Apr 2026 08:47:16 +0200
Subject: [PATCH 092/391] chore(tooling): Add dotagents configuration (#5230)

* meta: Add dotagents configuration

Sets up dotagents to manage AI agent skills declaratively via agents.toml.
Previously committed skills are now managed by dotagents and gitignored.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* meta: Keep custom skills alongside dotagents-managed ones

Use a nested .gitignore in .claude/skills/ to ignore dotagents-managed
skills while preserving repo-specific custom skills (create-java-pr, test).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Declare built-in skills

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .claude/skills/.gitignore |  8 ++++++++
 .gitignore                |  3 +++
 agents.toml               | 33 +++++++++++++++++++++++++++++++++
 3 files changed, 44 insertions(+)
 create mode 100644 .claude/skills/.gitignore
 create mode 100644 agents.toml

diff --git a/.claude/skills/.gitignore b/.claude/skills/.gitignore
new file mode 100644
index 00000000000..08243027e52
--- /dev/null
+++ b/.claude/skills/.gitignore
@@ -0,0 +1,8 @@
+# Ignore dotagents-managed skills (synced from agents.toml)
+*
+# Keep custom repo-specific skills
+!.gitignore
+!create-java-pr/
+!create-java-pr/**
+!test/
+!test/**
diff --git a/.gitignore b/.gitignore
index f232c32db51..a7899736a86 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,3 +34,6 @@ spy.log
 # Local Claude Code settings/state that should not be committed
 .claude/settings.local.json
 .claude/worktrees/
+# Auto-generated by dotagents — do not commit these files.
+agents.lock
+.agents/.gitignore
diff --git a/agents.toml b/agents.toml
new file mode 100644
index 00000000000..b2347f8e7e6
--- /dev/null
+++ b/agents.toml
@@ -0,0 +1,33 @@
+# Whenever you make changes to this file, run the following to update all generated dotagent files 
+# npx @sentry/dotagents install
+# npx @sentry/dotagents sync
+
+version = 1
+
+[[skills]]
+name = "dotagents"
+source = "getsentry/dotagents"
+
+[[skills]]
+name = "sentry-workflow"
+source = "getsentry/sentry-for-ai"
+
+[[skills]]
+name = "sentry-fix-issues"
+source = "getsentry/sentry-for-ai"
+
+[[skills]]
+name = "sentry-code-review"
+source = "getsentry/sentry-for-ai"
+
+[[skills]]
+name = "sentry-pr-code-review"
+source = "getsentry/sentry-for-ai"
+
+[[skills]]
+name = "create-java-pr"
+source = "path:.agents/skills/create-java-pr"
+
+[[skills]]
+name = "test"
+source = "path:.agents/skills/test"

From 2195398893bdc987254ef070f604099a41630503 Mon Sep 17 00:00:00 2001
From: Stephanie Anderson <stephanie.anderson@sentry.io>
Date: Wed, 1 Apr 2026 14:49:06 +0200
Subject: [PATCH 093/391] chore: Update validate-pr workflow (#5252)

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/workflows/validate-pr.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/validate-pr.yml b/.github/workflows/validate-pr.yml
index 44da67faa43..10fe894067a 100644
--- a/.github/workflows/validate-pr.yml
+++ b/.github/workflows/validate-pr.yml
@@ -10,7 +10,7 @@ jobs:
     permissions:
       pull-requests: write
     steps:
-      - uses: getsentry/github-workflows/validate-pr@0b52fc6a867b744dcbdf5d25c18bc8d1c95710e1
+      - uses: getsentry/github-workflows/validate-pr@71588ddf95134f804e82c5970a8098588e2eaecd
         with:
           app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
           private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}

From 327ca5122afdf678e205cff989c6882dd21664dd Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 8 Apr 2026 14:47:04 +0200
Subject: [PATCH 094/391] perf(init): Do not retrieve ActivityManager if API <
 35 (#5275)

* perf(init): Do not retrieve ActivityManager if API < 35

* Changelog
---
 CHANGELOG.md                                  |  4 +++
 .../core/performance/AppStartMetrics.java     | 27 ++++++++++---------
 2 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6bd3b127948..7c2f14fdeaa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,10 @@
 - Android: Attachments on the scope will now be synced to native ([#5211](https://github.com/getsentry/sentry-java/pull/5211))
 - Add THIRD_PARTY_NOTICES.md for vendored third-party code, bundled as SENTRY_THIRD_PARTY_NOTICES.md in the sentry JAR under META-INF ([#5186](https://github.com/getsentry/sentry-java/pull/5186))
 
+### Improvements
+
+- Do not retrieve `ActivityManager` if API < 35 on SDK init ([#5275](https://github.com/getsentry/sentry-java/pull/5275))
+
 ## 8.37.1
 
 ### Fixes
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
index 1bb95b9061a..746805fcfdc 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
@@ -338,19 +338,20 @@ public void registerLifecycleCallbacks(final @NotNull Application application) {
     appLaunchedInForeground.resetValue();
     application.registerActivityLifecycleCallbacks(instance);
 
-    final @Nullable ActivityManager activityManager =
-        (ActivityManager) application.getSystemService(Context.ACTIVITY_SERVICE);
-
-    if (activityManager != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
-      final List<ApplicationStartInfo> historicalProcessStartReasons =
-          activityManager.getHistoricalProcessStartReasons(1);
-      if (!historicalProcessStartReasons.isEmpty()) {
-        final @NotNull ApplicationStartInfo info = historicalProcessStartReasons.get(0);
-        if (info.getStartupState() == ApplicationStartInfo.STARTUP_STATE_STARTED) {
-          if (info.getStartType() == ApplicationStartInfo.START_TYPE_COLD) {
-            appStartType = AppStartType.COLD;
-          } else {
-            appStartType = AppStartType.WARM;
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+      final @Nullable ActivityManager activityManager =
+          (ActivityManager) application.getSystemService(Context.ACTIVITY_SERVICE);
+      if (activityManager != null) {
+        final List<ApplicationStartInfo> historicalProcessStartReasons =
+            activityManager.getHistoricalProcessStartReasons(1);
+        if (!historicalProcessStartReasons.isEmpty()) {
+          final @NotNull ApplicationStartInfo info = historicalProcessStartReasons.get(0);
+          if (info.getStartupState() == ApplicationStartInfo.STARTUP_STATE_STARTED) {
+            if (info.getStartType() == ApplicationStartInfo.START_TYPE_COLD) {
+              appStartType = AppStartType.COLD;
+            } else {
+              appStartType = AppStartType.WARM;
+            }
           }
         }
       }

From b572de2f2ac4c5431e8279851cc41cd5b344459c Mon Sep 17 00:00:00 2001
From: romtsn <4999776+romtsn@users.noreply.github.com>
Date: Wed, 8 Apr 2026 14:40:35 +0000
Subject: [PATCH 095/391] release: 8.38.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7c2f14fdeaa..f78a541171c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.38.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 3ce5df53b45..aa2f556e2b3 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.9.0
 
 # Release information
-versionName=8.37.1
+versionName=8.38.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From cd0981b5927b7c57c40dc519d3a690d0af884640 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 13 Apr 2026 14:05:10 +0200
Subject: [PATCH 096/391] chore(deps): update Native SDK to v0.13.6 (#5277)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 8 ++++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f78a541171c..d4a9266f261 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+### Dependencies
+
+- Bump Native SDK from v0.13.3 to v0.13.6 ([#5277](https://github.com/getsentry/sentry-java/pull/5277))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0136)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.13.3...0.13.6)
+
 ## 8.38.0
 
 ### Features
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index eb7ab86e4bd..93cb7b79158 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -151,7 +151,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.3" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.6" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 7935b26106c57393d64dc47bed2877617fb3cec3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 14 Apr 2026 11:57:17 +0200
Subject: [PATCH 097/391] build(deps): bump actions/upload-artifact from 7.0.0
 to 7.0.1 (#5286)

Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 7.0.0 to 7.0.1.
- [Release notes](https://github.com/actions/upload-artifact/releases)
- [Commits](https://github.com/actions/upload-artifact/compare/bbbca2ddaa5d8feaa63e36b76fdaad77386f024f...043fb46d1a93c77aae656e7c1c64a875d1fc6a0a)

---
updated-dependencies:
- dependency-name: actions/upload-artifact
  dependency-version: 7.0.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 4 ++--
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 8 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 750be7ca2e4..d288bbef8ae 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -94,7 +94,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: test-results-AGP${{ matrix.agp }}-Integrations${{ matrix.integrations }}
           path: |
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 06fa061d4ac..5debd3ad5a2 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -53,7 +53,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: test-results-build
           path: |
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 446228943b5..46b9665a099 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -44,7 +44,7 @@ jobs:
         run: make assembleUiTestCriticalRelease
 
       - name: Upload APK artifact
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: ${{env.APK_ARTIFACT_NAME}}
           path: "${{env.BASE_PATH}}/${{env.BUILD_PATH}}/${{env.APK_NAME}}"
@@ -141,7 +141,7 @@ jobs:
 
       - name: Upload Maestro test results
         if: ${{ always() }}
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: maestro-logs-${{ matrix.api-level }}-${{ matrix.arch }}-${{ matrix.target }}
           path: "${{env.BASE_PATH}}/maestro-logs"
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 62d2d5caa43..3ba2d299e54 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -32,7 +32,7 @@ jobs:
         run: make publish
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: ${{ github.sha }}
           if-no-files-found: error
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 3e57dfd907e..9ac07b7b3ee 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -150,7 +150,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: test-results-springboot-2-${{ matrix.springboot-version }}
           path: |
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 4abb488387a..963b6976cc2 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -150,7 +150,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: test-results-springboot-3-${{ matrix.springboot-version }}
           path: |
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 6466abb58ae..97fd6476fed 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -150,7 +150,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: test-results-springboot-4-${{ matrix.springboot-version }}
           path: |
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index f225be8faf6..321d6ae5652 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -153,7 +153,7 @@ jobs:
 
       - name: Upload test results
         if: always()
-        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7
+        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
         with:
           name: test-results-${{ matrix.sample }}-${{ matrix.agent }}-${{ matrix.agent-auto-init }}-system-test
           path: |

From 3af77f43495c957d88472975c0bdb982edb8411d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 14 Apr 2026 11:57:46 +0200
Subject: [PATCH 098/391] build(deps): bump actions/create-github-app-token
 from 3.0.0 to 3.1.1 (#5287)

Bumps [actions/create-github-app-token](https://github.com/actions/create-github-app-token) from 3.0.0 to 3.1.1.
- [Release notes](https://github.com/actions/create-github-app-token/releases)
- [Commits](https://github.com/actions/create-github-app-token/compare/f8d387b68d61c58ab83c6c016672934102569859...1b10c78c7865c340bc4f6099eb2f838309f1e8c3)

---
updated-dependencies:
- dependency-name: actions/create-github-app-token
  dependency-version: 3.1.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index eb99dca7f25..d2b9eaf45a2 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -23,7 +23,7 @@ jobs:
     steps:
       - name: Get auth token
         id: token
-        uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v3.0.0
+        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
         with:
           app-id: ${{ vars.SENTRY_RELEASE_BOT_CLIENT_ID }}
           private-key: ${{ secrets.SENTRY_RELEASE_BOT_PRIVATE_KEY }}

From 0675272ae2a242c9db25fe96485f5167d21912ef Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 14 Apr 2026 12:01:00 +0200
Subject: [PATCH 099/391] build(deps): bump actions/github-script from 8.0.0 to
 9.0.0 (#5285)

Bumps [actions/github-script](https://github.com/actions/github-script) from 8.0.0 to 9.0.0.
- [Release notes](https://github.com/actions/github-script/releases)
- [Commits](https://github.com/actions/github-script/compare/ed597411d8f924073f98dfc5c65a23a2325f34cd...3a2844b7e9c422d3c10d287c895573f7108da1b3)

---
updated-dependencies:
- dependency-name: actions/github-script
  dependency-version: 9.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/changes-in-high-risk-code.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/changes-in-high-risk-code.yml b/.github/workflows/changes-in-high-risk-code.yml
index e22fa135412..4ecc23619a4 100644
--- a/.github/workflows/changes-in-high-risk-code.yml
+++ b/.github/workflows/changes-in-high-risk-code.yml
@@ -34,7 +34,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Comment on PR to notify of changes in high risk files
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         env:
           high_risk_code: ${{ needs.files-changed.outputs.high_risk_code_files }}
         with:

From ce4b2c14da6fce40953fc11fc5df65b2839d31e1 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 15 Apr 2026 00:10:39 +0200
Subject: [PATCH 100/391] chore(deps): update Gradle to v9.4.1 (#5063)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* chore: update scripts/update-gradle.sh to v9.4.1

* Fix build

* fix dependsOn

* align shadow plugin version

* Fix apollo version

* Format code

* fix(build): remove Spring Boot 2 Gradle plugin for Gradle 9 compatibility (#5263)

* fix(build): remove Spring Boot 2 Gradle plugin for Gradle 9 compatibility

The Spring Boot 2.7.x Gradle plugin uses removed Gradle APIs
(LenientConfiguration.getFiles()) that are incompatible with Gradle 9.

Library modules (sentry-spring, sentry-spring-boot, sentry-spring-boot-starter):
- Replace SpringBootPlugin.BOM_COORDINATES with direct BOM reference
  via version catalog (libs.springboot2.bom)
- Remove the 'apply false' plugin declaration entirely

Sample apps (spring-boot, webflux, otel, netflix-dgs):
- Replace Spring Boot plugin with Shadow plugin for fat JAR creation
- Add application plugin for main class configuration
- Use platform(libs.springboot2.bom) for dependency version management
- Configure shadow JAR to merge Spring metadata files
- Replace BootRun task with JavaExec in otel sample

* fix: set duplicatesStrategy=INCLUDE for shadow JAR spring.factories merge

Shadow plugin 9.x defaults to DuplicatesStrategy.EXCLUDE, which drops
duplicate META-INF/spring.factories entries before transformers can
merge them. Setting INCLUDE allows the AppendingTransformer to see all
entries and properly concatenate spring.factories from all JARs.

Without this, the shadow JAR only contains spring.factories from a
single dependency, causing Spring Boot auto-configuration to fail
(e.g. missing RestTemplateBuilder, no embedded web server).

* fix: remove duplicate shadow plugin entry in version catalog

* Format code

* fix: update system test runner for shadow JAR compatibility

- Auto-detect shadowJar vs bootJar build task based on build.gradle.kts
- Add fallback HTTP readiness check for shadow JAR apps that lack
  actuator endpoints (actuator web endpoints don't work in flat JARs)
- Append spring-autoconfigure-metadata.properties in shadow JAR config

* fix(otel): use DuplicatesStrategy.INCLUDE for otel agent shadow JAR

Shadow 9.x enforces duplicatesStrategy before transformers run, so
DuplicatesStrategy.FAIL prevents mergeServiceFiles from merging
inst/META-INF/services/ files that exist in both the upstream OTel
agent JAR and the isolated distro libs. Switching to INCLUDE lets
the transformer see all duplicates and merge them correctly.

* Exclude test-support modules from api validation

* Verbose system test output and wire inputs for them properly

* align coroutines version to 1.9.0 for system tests

* fix(otel): use mergeServiceFiles path instead of include for Shadow 9.x

Shadow 9.x's ServiceFileTransformer strips the `inst/` prefix when using
`include("inst/META-INF/services/*")`, placing merged service files under
`META-INF/services/` instead of `inst/META-INF/services/`. This breaks
the OTel agent's classloader which expects isolated services under `inst/`.

Using `path = "inst/META-INF/services"` preserves the correct output path.

Also add missing `duplicatesStrategy = DuplicatesStrategy.INCLUDE` to
console-otlp, log4j2, and console-opentelemetry-noagent shadow JARs
so that mergeServiceFiles and Log4j2 transformers can see duplicates
before they are deduplicated.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(otel): add default mergeServiceFiles for bootstrap service relocation

Shadow 9.x only applies package relocations to service files that are
claimed by a ServiceFileTransformer. The ContextStorageProvider service
file at META-INF/services/ was not being relocated because it wasn't
handled by any transformer — only the inst/META-INF/services/ files were.

Adding a default mergeServiceFiles() call ensures bootstrap service files
(like ContextStorageProvider) go through the transformer and get properly
relocated to their shaded paths.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(spring-boot2): pre-merge Spring metadata for Shadow 9.x compatibility

Shadow 9.x enforces DuplicatesStrategy before transformers run, which
breaks the `append` transformer for spring.factories and other Spring
metadata files. Only the last copy survives instead of being concatenated.

Replace `append` calls with a pre-merge task that manually concatenates
Spring metadata files (spring.factories, spring.handlers, spring.schemas,
spring-autoconfigure-metadata.properties) from the runtime classpath
before the shadow JAR is built. The merged files are included first in
the shadow JAR so they take precedence over duplicates from dependency
JARs.

This fixes the PersonSystemTest failure where @SentrySpan AOP and JDBC
instrumentation weren't working because SentryAutoConfiguration wasn't
properly registered in the merged spring.factories.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Format code

* fix(lint): suppress OldTargetApi for uitest-android module

Lint 8.13.1 (set via android.experimental.lint.version) expects targetSdk 37
but we target 36. This is a test-only module so suppressing is safe.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(spring-boot2): make mergeSpringMetadata configuration-cache compatible

Resolve the runtime classpath at configuration time (not inside doLast)
so the task doesn't capture Gradle script object references that can't
be serialized by the configuration cache.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* formatting

* fix(spring-boot2): replace from() with doLast JAR patching for spring metadata

The from() approach with DuplicatesStrategy.INCLUDE doesn't work because
dependency JARs' spring.factories overwrites the pre-merged version.

Instead, let the shadow JAR build normally, then use a doLast action
to replace the Spring metadata files in the built JAR with the properly
merged versions using the NIO ZIP filesystem API.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* formatting

* fix(spring-boot2): merge AutoConfiguration.imports + doLast JAR patching

The shadow JAR was missing the embedded web server auto-configuration
because AutoConfiguration.imports (used by SB 2.7+) had duplicate entries
from multiple dependency JARs, with only the last copy surviving.

Add AutoConfiguration.imports to the pre-merge file list and use doLast
JAR patching via NIO ZIP filesystem to replace metadata files after
the shadow JAR is built, avoiding the DuplicatesStrategy issue entirely.

Also suppress OldTargetApi lint for uitest-android-benchmark module.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(spring-boot2): also merge ManagementContextConfiguration.imports

This file has duplicate entries across actuator JARs and needs the
same pre-merge treatment as AutoConfiguration.imports.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* formatting

* fix(spring-boot2): use separate patchSpringMetadata task for JAR patching

The doLast on shadowJar doesn't run when the task is cached/up-to-date.
Move JAR patching to a separate `patchSpringMetadata` task that is
finalized by shadowJar, ensuring it always runs. Also use recursive
walkTopDown to handle nested directories (e.g. META-INF/spring/).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* formatting

* fix(spring-boot2): revert to doLast on shadowJar for Spring metadata patching

The separate patchSpringMetadata task approach caused regressions — the
finalizedBy relationship didn't reliably execute the patching in CI.

Revert to doLast directly on shadowJar with outputs.upToDateWhen { false }
to ensure the patching always runs. Also use walkTopDown for recursive
directory traversal (needed for META-INF/spring/ subdirectory).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* formatting

* fix(spring-boot2): inline Spring metadata merge into shadowJar doLast

Replace the separate mergeSpringMetadata task with inline doLast on
shadowJar that resolves runtimeClasspath at execution time (not
configuration time). This ensures all project dependency JARs are built
before their spring.factories entries are read and merged.

Verified locally: 20/21 system tests pass. Only PersonSystemTest
'create person works' fails due to @SentrySpan AOP limitation in
shadow JARs.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* formatting

* fix(build): make Spring sample shadowJar patching config-cache safe

* fix(build): merge Spring metadata properties in shadow jars

* fix(build): preserve escaped spring metadata keys

* refactor(samples): drop no-op spring shadow service merging

* test(android): Avoid ANR profiling integration test race

Drive the ANR profiling state-machine test synchronously instead of starting the background polling thread.

The previous version could read the queue-backed profile store while the polling thread was still appending stack traces, which made the release unit test flaky with NoSuchElementException in QueueFile iteration.

Co-Authored-By: Codex <noreply@openai.com>

* fix(test): Require actuator health for Spring readiness

* ref(build): Share Spring metadata file list

Move the Spring metadata entry list into MergeSpringMetadataAction so
the Spring sample shadowJar tasks use one source of truth.

Drop the temporary system-test-runner unit test and keep verification
on the existing Spring Boot system test flow.

Co-Authored-By: Codex <noreply@openai.com>

* docs(build): Document Spring metadata merge action

Explain that MergeSpringMetadataAction patches shadow JARs by
merging Spring metadata with file-specific semantics and by
preserving service-provider registrations from the runtime
classpath.

This keeps the intent of the build logic clear without changing
behavior.

Co-Authored-By: Codex <noreply@openai.com>

* build(opentelemetry): Fail agent shadow duplicates by default

Set the final agent shadowJar to fail on unexpected duplicate entries
while still allowing service descriptors to merge in the bootstrap and
inst paths. This keeps duplicate handling strict without breaking the
service file transformers Shadow still relies on.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Codex <noreply@openai.com>

* Apply suggestion from @romtsn

---------

Co-authored-by: GitHub <noreply@github.com>
Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: Alexander Dinauer <adinauer@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Codex <noreply@openai.com>
---
 CHANGELOG.md                                  |   7 +
 build.gradle.kts                              |  12 +-
 buildSrc/src/main/java/Config.kt              |   2 +-
 .../main/java/MergeSpringMetadataAction.kt    | 292 +++++++++
 gradle.properties                             |   2 +-
 gradle/libs.versions.toml                     |   5 +-
 gradle/wrapper/gradle-wrapper.properties      |   2 +-
 .../core/anr/AnrProfilingIntegrationTest.kt   |   2 +-
 .../build.gradle.kts                          |   2 +
 .../sentry-uitest-android/build.gradle.kts    |   2 +
 .../build.gradle.kts                          |  20 +-
 .../build.gradle.kts                          |   7 +-
 .../build.gradle.kts                          |   7 +-
 .../sentry-samples-console/build.gradle.kts   |   6 +-
 .../sentry-samples-jul/build.gradle.kts       |   6 +-
 .../sentry-samples-log4j2/build.gradle.kts    |   7 +-
 .../sentry-samples-logback/build.gradle.kts   |   6 +-
 .../build.gradle.kts                          |  30 +-
 .../sentry-samples-spring-7/build.gradle.kts  |   4 +
 .../build.gradle.kts                          |   4 +
 .../build.gradle.kts                          |   4 +
 .../build.gradle.kts                          |   4 +
 .../build.gradle.kts                          |   4 +
 .../build.gradle.kts                          |   4 +
 .../build.gradle.kts                          |   7 +
 .../build.gradle.kts                          |   7 +
 .../build.gradle.kts                          |   8 +-
 .../build.gradle.kts                          |  35 +-
 .../build.gradle.kts                          |  42 +-
 .../build.gradle.kts                          |   7 +
 .../build.gradle.kts                          |  34 +-
 .../build.gradle.kts                          |  37 +-
 .../build.gradle.kts                          |   7 +
 .../sentry-samples-spring/build.gradle.kts    |  11 +-
 sentry-spring-boot-starter/build.gradle.kts   |   4 +-
 sentry-spring-boot/build.gradle.kts           |   6 +-
 sentry-spring/build.gradle.kts                |   4 +-
 .../api/sentry-system-test-support.api        | 619 ------------------
 sentry-system-test-support/build.gradle.kts   |   4 +-
 .../systemtest/graphql/GraphqlTestClient.kt   |   8 +-
 .../io/sentry/systemtest/util/TestHelper.kt   |   4 +-
 .../api/sentry-test-support.api               |  75 ---
 test/system-test-runner.py                    |  15 +-
 43 files changed, 620 insertions(+), 755 deletions(-)
 create mode 100644 buildSrc/src/main/java/MergeSpringMetadataAction.kt
 delete mode 100644 sentry-system-test-support/api/sentry-system-test-support.api
 delete mode 100644 sentry-test-support/api/sentry-test-support.api

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d4a9266f261..8357f0699df 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,11 +2,18 @@
 
 ## Unreleased
 
+### Internal
+
+- Bump AGP version from v8.6.0 to v8.13.1 ([#5063](https://github.com/getsentry/sentry-java/pull/5063))
+
 ### Dependencies
 
 - Bump Native SDK from v0.13.3 to v0.13.6 ([#5277](https://github.com/getsentry/sentry-java/pull/5277))
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0136)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.13.3...0.13.6)
+- Bump Gradle from v8.14.3 to v9.4.1 ([#5063](https://github.com/getsentry/sentry-java/pull/5063))
+  - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v941)
+  - [diff](https://github.com/gradle/gradle/compare/v8.14.3...v9.4.1)
 
 ## 8.38.0
 
diff --git a/build.gradle.kts b/build.gradle.kts
index 376d0652832..6656e00e49a 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -87,7 +87,9 @@ apiValidation {
             "test-app-sentry",
             "test-app-size",
             "sentry-samples-netflix-dgs",
-            "sentry-samples-console-otlp"
+            "sentry-samples-console-otlp",
+            "sentry-test-support",
+            "sentry-system-test-support"
         )
     )
 }
@@ -249,9 +251,13 @@ tasks.register("buildForCodeQL") {
         }
         .forEach { proj ->
             if (proj.plugins.hasPlugin("com.android.library")) {
-                this.dependsOn(proj.tasks.findByName("compileReleaseUnitTestSources"))
+                proj.tasks.findByName("compileReleaseUnitTestSources")?.let { testTask ->
+                    this.dependsOn(testTask)
+                }
             } else {
-                this.dependsOn(proj.tasks.findByName("testClasses"))
+                proj.tasks.findByName("testClasses")?.let { testTask ->
+                    this.dependsOn(testTask)
+                }
             }
         }
 }
diff --git a/buildSrc/src/main/java/Config.kt b/buildSrc/src/main/java/Config.kt
index b5d1dafeb74..3285db23a98 100644
--- a/buildSrc/src/main/java/Config.kt
+++ b/buildSrc/src/main/java/Config.kt
@@ -2,7 +2,7 @@
 import java.math.BigDecimal
 
 object Config {
-    val AGP = System.getenv("VERSION_AGP") ?: "8.6.0"
+    val AGP = System.getenv("VERSION_AGP") ?: "8.13.1"
     val kotlinStdLib = "stdlib-jdk8"
     val kotlinStdLibVersionAndroid = "1.9.24"
     val kotlinTestJunit = "test-junit"
diff --git a/buildSrc/src/main/java/MergeSpringMetadataAction.kt b/buildSrc/src/main/java/MergeSpringMetadataAction.kt
new file mode 100644
index 00000000000..2df744924cb
--- /dev/null
+++ b/buildSrc/src/main/java/MergeSpringMetadataAction.kt
@@ -0,0 +1,292 @@
+import java.net.URI
+import java.nio.file.FileSystems
+import java.nio.file.Files
+import java.util.LinkedHashSet
+import java.util.zip.ZipFile
+import org.gradle.api.Action
+import org.gradle.api.Task
+import org.gradle.api.file.FileCollection
+import org.gradle.api.tasks.bundling.AbstractArchiveTask
+
+/**
+ * Patches a built shadow JAR by merging Spring metadata and service descriptor files from the
+ * runtime classpath into the final archive.
+ *
+ * Spring metadata files do not all share the same merge semantics, so this action merges
+ * `spring.factories` as list properties, `.imports` files as line-based metadata, and other Spring
+ * metadata as key/value properties. It also deduplicates service-provider configuration entries
+ * under `META-INF/services` so the flat executable JAR keeps the runtime registrations it needs.
+ */
+class MergeSpringMetadataAction(
+    private val runtimeClasspath: FileCollection,
+    private val springMetadataFiles: List<String>,
+) : Action<Task> {
+    companion object {
+        val DEFAULT_SPRING_METADATA_FILES =
+            listOf(
+                "META-INF/spring.factories",
+                "META-INF/spring.handlers",
+                "META-INF/spring.schemas",
+                "META-INF/spring-autoconfigure-metadata.properties",
+                "META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports",
+                "META-INF/spring/org.springframework.boot.actuate.autoconfigure.web.ManagementContextConfiguration.imports",
+            )
+    }
+
+    override fun execute(task: Task) {
+        val archiveTask = task as AbstractArchiveTask
+        val jar = archiveTask.archiveFile.get().asFile
+        val runtimeJars = runtimeClasspath.files.filter { it.name.endsWith(".jar") }
+        val uri = URI.create("jar:${jar.toURI()}")
+
+        FileSystems.newFileSystem(uri, mapOf("create" to "false")).use { fs ->
+            springMetadataFiles.forEach { entryPath ->
+                val target = fs.getPath(entryPath)
+                val contents = mutableListOf<String>()
+
+                if (Files.exists(target)) {
+                    contents.add(Files.readString(target))
+                }
+
+                runtimeJars.forEach { depJar ->
+                    try {
+                        ZipFile(depJar).use { zip ->
+                            val entry = zip.getEntry(entryPath)
+                            if (entry != null) {
+                                contents.add(zip.getInputStream(entry).bufferedReader().readText())
+                            }
+                        }
+                    } catch (_: Exception) {
+                        // Ignore non-zip files on the runtime classpath.
+                    }
+                }
+
+                val merged =
+                    when {
+                        entryPath == "META-INF/spring.factories" -> mergeListProperties(contents)
+                        entryPath.endsWith(".imports") -> mergeLineBasedMetadata(contents)
+                        else -> mergeMapProperties(contents)
+                    }
+
+                if (merged.isNotEmpty()) {
+                    if (target.parent != null) {
+                        Files.createDirectories(target.parent)
+                    }
+                    Files.write(target, merged.toByteArray())
+                }
+            }
+
+            val serviceEntries = linkedSetOf<String>()
+
+            runtimeJars.forEach { depJar ->
+                try {
+                    ZipFile(depJar).use { zip ->
+                        val entries = zip.entries()
+                        while (entries.hasMoreElements()) {
+                            val entry = entries.nextElement()
+                            if (!entry.isDirectory && entry.name.startsWith("META-INF/services/")) {
+                                serviceEntries.add(entry.name)
+                            }
+                        }
+                    }
+                } catch (_: Exception) {
+                    // Ignore non-zip files on the runtime classpath.
+                }
+            }
+
+            serviceEntries.forEach { entryPath ->
+                val providers = LinkedHashSet<String>()
+                val target = fs.getPath(entryPath)
+
+                if (Files.exists(target)) {
+                    Files.newBufferedReader(target).useLines { lines ->
+                        lines.forEach { line ->
+                            val provider = line.trim()
+                            if (provider.isNotEmpty() && !provider.startsWith("#")) {
+                                providers.add(provider)
+                            }
+                        }
+                    }
+                }
+
+                runtimeJars.forEach { depJar ->
+                    try {
+                        ZipFile(depJar).use { zip ->
+                            val entry = zip.getEntry(entryPath)
+                            if (entry != null) {
+                                zip.getInputStream(entry).bufferedReader().useLines { lines ->
+                                    lines.forEach { line ->
+                                        val provider = line.trim()
+                                        if (provider.isNotEmpty() && !provider.startsWith("#")) {
+                                            providers.add(provider)
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    } catch (_: Exception) {
+                        // Ignore non-zip files on the runtime classpath.
+                    }
+                }
+
+                if (providers.isNotEmpty()) {
+                    if (target.parent != null) {
+                        Files.createDirectories(target.parent)
+                    }
+                    Files.write(target, providers.joinToString(separator = "\n", postfix = "\n").toByteArray())
+                }
+            }
+        }
+    }
+
+    private fun mergeLineBasedMetadata(contents: List<String>): String {
+        val lines = LinkedHashSet<String>()
+
+        contents.forEach { content ->
+            content.lineSequence().forEach { rawLine ->
+                val line = rawLine.trim()
+                if (line.isNotEmpty() && !line.startsWith("#")) {
+                    lines.add(line)
+                }
+            }
+        }
+
+        return if (lines.isEmpty()) "" else lines.joinToString(separator = "\n", postfix = "\n")
+    }
+
+    private fun mergeMapProperties(contents: List<String>): String {
+        val merged = linkedMapOf<String, String>()
+
+        contents.forEach { content ->
+            parseProperties(content).forEach { (key, value) ->
+                merged[key] = value
+            }
+        }
+
+        return if (merged.isEmpty()) {
+            ""
+        } else {
+            merged.entries.joinToString(separator = "\n", postfix = "\n") { (key, value) -> "$key=$value" }
+        }
+    }
+
+    private fun mergeListProperties(contents: List<String>): String {
+        val merged = linkedMapOf<String, LinkedHashSet<String>>()
+
+        contents.forEach { content ->
+            parseProperties(content).forEach { (key, value) ->
+                val values = merged.getOrPut(key) { LinkedHashSet() }
+                value
+                    .split(',')
+                    .map(String::trim)
+                    .filter(String::isNotEmpty)
+                    .forEach(values::add)
+            }
+        }
+
+        return if (merged.isEmpty()) {
+            ""
+        } else {
+            merged.entries.joinToString(separator = "\n", postfix = "\n") { (key, values) ->
+                "$key=${values.joinToString(separator = ",")}"
+            }
+        }
+    }
+
+    private fun parseProperties(content: String): List<Pair<String, String>> {
+        val logicalLines = mutableListOf<String>()
+        val current = StringBuilder()
+
+        content.lineSequence().forEach { rawLine ->
+            val line = rawLine.trim()
+            if (current.isEmpty() && (line.isEmpty() || line.startsWith("#") || line.startsWith("!"))) {
+                return@forEach
+            }
+
+            val normalized = if (current.isEmpty()) line else line.trimStart()
+            current.append(
+                if (endsWithContinuation(rawLine)) normalized.dropLast(1) else normalized,
+            )
+
+            if (!endsWithContinuation(rawLine)) {
+                logicalLines.add(current.toString())
+                current.setLength(0)
+            }
+        }
+
+        if (current.isNotEmpty()) {
+            logicalLines.add(current.toString())
+        }
+
+        return logicalLines.map { line ->
+            val separatorIndex = findSeparatorIndex(line)
+            if (separatorIndex < 0) {
+                line to ""
+            } else {
+                val keyEnd = trimTrailingWhitespace(line, separatorIndex)
+                val valueStart = findValueStart(line, separatorIndex)
+                line.substring(0, keyEnd) to line.substring(valueStart).trim()
+            }
+        }
+    }
+
+    private fun endsWithContinuation(line: String): Boolean {
+        var backslashCount = 0
+
+        for (index in line.length - 1 downTo 0) {
+            if (line[index] == '\\') {
+                backslashCount++
+            } else {
+                break
+            }
+        }
+
+        return backslashCount % 2 == 1
+    }
+
+    private fun findSeparatorIndex(line: String): Int {
+        var backslashCount = 0
+
+        line.forEachIndexed { index, char ->
+            if (char == '\\') {
+                backslashCount++
+            } else {
+                val isEscaped = backslashCount % 2 == 1
+                if (!isEscaped && (char == '=' || char == ':' || char.isWhitespace())) {
+                    return index
+                }
+                backslashCount = 0
+            }
+        }
+
+        return -1
+    }
+
+    private fun trimTrailingWhitespace(line: String, endExclusive: Int): Int {
+        var end = endExclusive
+
+        while (end > 0 && line[end - 1].isWhitespace()) {
+            end--
+        }
+
+        return end
+    }
+
+    private fun findValueStart(line: String, separatorIndex: Int): Int {
+        var valueStart = separatorIndex
+
+        while (valueStart < line.length && line[valueStart].isWhitespace()) {
+            valueStart++
+        }
+
+        if (valueStart < line.length && (line[valueStart] == '=' || line[valueStart] == ':')) {
+            valueStart++
+        }
+
+        while (valueStart < line.length && line[valueStart].isWhitespace()) {
+            valueStart++
+        }
+
+        return valueStart
+    }
+}
diff --git a/gradle.properties b/gradle.properties
index aa2f556e2b3..d9d50f79f73 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -9,7 +9,7 @@ org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 
 # AndroidX required by AGP >= 3.6.x
 android.useAndroidX=true
-android.experimental.lint.version=8.9.0
+android.experimental.lint.version=8.13.1
 
 # Release information
 versionName=8.38.0
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 93cb7b79158..d02e3249df7 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -61,13 +61,13 @@ detekt = { id = "io.gitlab.arturbosch.detekt", version = "1.23.8" }
 jacoco-android = { id = "com.mxalbert.gradle.jacoco-android", version = "0.2.0" }
 kover = { id = "org.jetbrains.kotlinx.kover", version = "0.7.3" }
 vanniktech-maven-publish = { id = "com.vanniktech.maven.publish", version = "0.30.0" }
-springboot2 = { id = "org.springframework.boot", version.ref = "springboot2" }
 springboot3 = { id = "org.springframework.boot", version.ref = "springboot3" }
 springboot4 = { id = "org.springframework.boot", version.ref = "springboot4" }
-spring-dependency-management = { id = "io.spring.dependency-management", version = "1.0.11.RELEASE" }
+spring-dependency-management = { id = "io.spring.dependency-management", version = "1.1.7" }
 gretty = { id = "org.gretty", version = "4.0.0" }
 animalsniffer = { id = "ru.vyarus.animalsniffer", version = "2.0.1" }
 sentry = { id = "io.sentry.android.gradle", version = "6.0.0-alpha.6"}
+shadow = { id = "com.gradleup.shadow", version = "9.4.1" }
 
 [libraries]
 apache-httpclient = { module = "org.apache.httpcomponents.client5:httpclient5", version = "5.0.4" }
@@ -158,6 +158,7 @@ slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
 slf4j-jdk14 = { module = "org.slf4j:slf4j-jdk14", version.ref = "slf4j" }
 slf4j2-api = { module = "org.slf4j:slf4j-api", version = "2.0.5" }
 spotlessLib = { module = "com.diffplug.spotless:com.diffplug.spotless.gradle.plugin", version.ref = "spotless"}
+springboot2-bom = { module = "org.springframework.boot:spring-boot-dependencies", version.ref = "springboot2" }
 springboot-starter = { module = "org.springframework.boot:spring-boot-starter", version.ref = "springboot2" }
 springboot-starter-graphql = { module = "org.springframework.boot:spring-boot-starter-graphql", version.ref = "springboot2" }
 springboot-starter-quartz = { module = "org.springframework.boot:spring-boot-starter-quartz", version.ref = "springboot2" }
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index d4081da476b..c61a118f7dd 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt
index c07bb4d71bb..2ae48fb3253 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrProfilingIntegrationTest.kt
@@ -174,7 +174,7 @@ class AnrProfilingIntegrationTest {
 
     val integration = AnrProfilingIntegration()
     integration.register(mockScopes, androidOptions)
-    integration.onForeground()
+    // Drive the state machine synchronously to avoid racing the background polling thread.
 
     SystemClock.setCurrentTimeMillis(1_000)
     integration.checkMainThread(mainThread)
diff --git a/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
index e6480d8b37d..4b5993644ee 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
@@ -81,6 +81,8 @@ android {
   lint {
     warningsAsErrors = true
     checkDependencies = true
+    // Suppress OldTargetApi: lint 8.13.1 expects API 37 but we target 36
+    disable += "OldTargetApi"
 
     // We run a full lint analysis as build part in CI, so skip vital checks for assemble tasks.
     checkReleaseBuilds = false
diff --git a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
index 0c32cbad941..a4d46405fb8 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
@@ -74,6 +74,8 @@ android {
   lint {
     warningsAsErrors = true
     checkDependencies = true
+    // Suppress OldTargetApi: lint 8.13.1 expects API 37 but we target 36
+    disable += "OldTargetApi"
 
     // We run a full lint analysis as build part in CI, so skip vital checks for assemble tasks.
     checkReleaseBuilds = false
diff --git a/sentry-opentelemetry/sentry-opentelemetry-agent/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-agent/build.gradle.kts
index 7ee17c09385..ef98d488bd1 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-agent/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-agent/build.gradle.kts
@@ -3,7 +3,7 @@ import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 plugins {
   `java-library`
   id("io.sentry.javadoc")
-  id("com.gradleup.shadow") version "8.3.6"
+  alias(libs.plugins.shadow)
 }
 
 fun relocatePackages(shadowJar: ShadowJar) {
@@ -133,7 +133,7 @@ tasks {
   // each CopySpec has
   // its own duplicatesStrategy
   register("isolateJavaagentLibs", Copy::class.java) {
-    dependsOn(findByName("relocateJavaagentLibs"))
+    findByName("relocateJavaagentLibs")?.let { task -> dependsOn(task) }
     with(isolateClasses(findByName("relocateJavaagentLibs")!!.outputs.files))
 
     into(project.layout.buildDirectory.file("isolated/javaagentLibs").get().asFile)
@@ -145,14 +145,26 @@ tasks {
   named("shadowJar", ShadowJar::class) {
     configurations = listOf(bootstrapLibs) + listOf(upstreamAgent)
 
-    dependsOn(findByName("isolateJavaagentLibs"))
+    findByName("isolateJavaagentLibs")?.let { task -> dependsOn(task) }
     from(findByName("isolateJavaagentLibs")!!.outputs)
 
     archiveClassifier.set("")
 
     duplicatesStrategy = DuplicatesStrategy.FAIL
 
-    mergeServiceFiles { include("inst/META-INF/services/*") }
+    filesMatching("META-INF/services/**") { duplicatesStrategy = DuplicatesStrategy.INCLUDE }
+    filesMatching("inst/META-INF/services/**") { duplicatesStrategy = DuplicatesStrategy.INCLUDE }
+
+    // Shadow 9.x only applies relocations to service files handled by a ServiceFileTransformer.
+    // We need two mergeServiceFiles calls:
+    // 1. Default path (META-INF/services) — ensures bootstrap service files get relocated
+    //    (e.g., ContextStorageProvider → shaded path). Without this, Shadow 9.x skips
+    //    relocation for service file names/contents not claimed by a transformer.
+    // 2. inst/ path — merges isolated agent service files from both the upstream agent
+    //    and the distro libs. Uses `path` instead of `include` filter because Shadow 9.x's
+    //    include() strips the `inst/` prefix on output.
+    mergeServiceFiles()
+    mergeServiceFiles { path = "inst/META-INF/services" }
     exclude("**/module-info.class")
     relocatePackages(this)
 
diff --git a/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
index 338241078ae..f5d14dc2c38 100644
--- a/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
@@ -5,7 +5,7 @@ plugins {
   application
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
-  id("com.github.johnrengelman.shadow") version "8.1.1"
+  alias(libs.plugins.shadow)
 }
 
 application { mainClass.set("io.sentry.samples.console.Main") }
@@ -48,6 +48,7 @@ dependencies {
 tasks.shadowJar {
   manifest { attributes["Main-Class"] = "io.sentry.samples.console.Main" }
   archiveClassifier.set("") // Remove the classifier so it replaces the regular JAR
+  duplicatesStrategy = DuplicatesStrategy.INCLUDE
   mergeServiceFiles()
 }
 
@@ -66,6 +67,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-console-otlp/build.gradle.kts b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
index 18836c89555..483f6bea799 100644
--- a/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
@@ -5,7 +5,7 @@ plugins {
   application
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
-  id("com.github.johnrengelman.shadow") version "8.1.1"
+  alias(libs.plugins.shadow)
 }
 
 application { mainClass.set("io.sentry.samples.console.Main") }
@@ -51,6 +51,7 @@ dependencies {
 tasks.shadowJar {
   manifest { attributes["Main-Class"] = "io.sentry.samples.console.Main" }
   archiveClassifier.set("") // Remove the classifier so it replaces the regular JAR
+  duplicatesStrategy = DuplicatesStrategy.INCLUDE
   mergeServiceFiles()
 }
 
@@ -69,6 +70,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-console/build.gradle.kts b/sentry-samples/sentry-samples-console/build.gradle.kts
index 0dc6183b4fc..c27196e96b8 100644
--- a/sentry-samples/sentry-samples-console/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console/build.gradle.kts
@@ -5,7 +5,7 @@ plugins {
   application
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
-  id("com.github.johnrengelman.shadow") version "8.1.1"
+  alias(libs.plugins.shadow)
 }
 
 application { mainClass.set("io.sentry.samples.console.Main") }
@@ -69,6 +69,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-jul/build.gradle.kts b/sentry-samples/sentry-samples-jul/build.gradle.kts
index 8b5f5057054..01e6a95f13d 100644
--- a/sentry-samples/sentry-samples-jul/build.gradle.kts
+++ b/sentry-samples/sentry-samples-jul/build.gradle.kts
@@ -5,7 +5,7 @@ plugins {
   application
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
-  id("com.github.johnrengelman.shadow") version "8.1.1"
+  alias(libs.plugins.shadow)
 }
 
 application { mainClass.set("io.sentry.samples.jul.Main") }
@@ -62,6 +62,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-log4j2/build.gradle.kts b/sentry-samples/sentry-samples-log4j2/build.gradle.kts
index dede2d9cb29..005e1116528 100644
--- a/sentry-samples/sentry-samples-log4j2/build.gradle.kts
+++ b/sentry-samples/sentry-samples-log4j2/build.gradle.kts
@@ -5,7 +5,7 @@ plugins {
   application
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
-  id("com.github.johnrengelman.shadow") version "8.1.1"
+  alias(libs.plugins.shadow)
 }
 
 application { mainClass.set("io.sentry.samples.log4j2.Main") }
@@ -45,6 +45,7 @@ dependencies {
 tasks.shadowJar {
   manifest { attributes["Main-Class"] = "io.sentry.samples.log4j2.Main" }
   archiveClassifier.set("") // Remove the classifier so it replaces the regular JAR
+  duplicatesStrategy = DuplicatesStrategy.INCLUDE
   mergeServiceFiles()
   // Use Log4j2 cache transformer to properly handle plugin files
   transform(
@@ -67,6 +68,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-logback/build.gradle.kts b/sentry-samples/sentry-samples-logback/build.gradle.kts
index ee6949c6c6b..05f96c346a8 100644
--- a/sentry-samples/sentry-samples-logback/build.gradle.kts
+++ b/sentry-samples/sentry-samples-logback/build.gradle.kts
@@ -5,7 +5,7 @@ plugins {
   application
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
-  id("com.github.johnrengelman.shadow") version "8.1.1"
+  alias(libs.plugins.shadow)
 }
 
 application { mainClass.set("io.sentry.samples.logback.Main") }
@@ -62,6 +62,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-netflix-dgs/build.gradle.kts b/sentry-samples/sentry-samples-netflix-dgs/build.gradle.kts
index ade18a0cbc1..202b8d8f058 100644
--- a/sentry-samples/sentry-samples-netflix-dgs/build.gradle.kts
+++ b/sentry-samples/sentry-samples-netflix-dgs/build.gradle.kts
@@ -2,12 +2,15 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-  alias(libs.plugins.springboot2)
-  alias(libs.plugins.spring.dependency.management)
+  java
+  application
+  alias(libs.plugins.shadow)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
 }
 
+application { mainClass.set("io.sentry.samples.netflix.dgs.NetlixDgsApplication") }
+
 group = "io.sentry.sample.spring-boot"
 
 version = "0.0.1-SNAPSHOT"
@@ -19,6 +22,7 @@ java.targetCompatibility = JavaVersion.VERSION_1_8
 repositories { mavenCentral() }
 
 dependencies {
+  implementation(platform(libs.springboot2.bom))
   implementation(libs.springboot.starter.web)
   implementation(Config.Libs.kotlinReflect)
   implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
@@ -32,6 +36,28 @@ dependencies {
   }
 }
 
+val runtimeClasspath = configurations.named("runtimeClasspath")
+
+// Configure the Shadow JAR (executable JAR with all dependencies)
+tasks.shadowJar {
+  manifest { attributes["Main-Class"] = "io.sentry.samples.netflix.dgs.NetlixDgsApplication" }
+  archiveClassifier.set("")
+
+  doLast(
+    MergeSpringMetadataAction(
+      runtimeClasspath.get(),
+      MergeSpringMetadataAction.DEFAULT_SPRING_METADATA_FILES,
+    )
+  )
+}
+
+tasks.jar {
+  enabled = false
+  dependsOn(tasks.shadowJar)
+}
+
+tasks.startScripts { dependsOn(tasks.shadowJar) }
+
 tasks.withType<Test>().configureEach { useJUnitPlatform() }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-samples/sentry-samples-spring-7/build.gradle.kts b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
index a8f2dc4da7c..e3300cd2841 100644
--- a/sentry-samples/sentry-samples-spring-7/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
@@ -73,6 +73,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
index 71ff985d67c..a7b2d939cdc 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
@@ -82,6 +82,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
index c3e8ba06fae..d43a628eb9a 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
@@ -110,6 +110,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
index 01e07fc2526..7329d5cc0ea 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
@@ -87,6 +87,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
index cdcf65711a8..a311b8a972e 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
@@ -66,6 +66,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
index f43cc47cc6d..d96e5602483 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
@@ -84,6 +84,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
index 86914467a6d..c7fc0106131 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
@@ -18,6 +18,9 @@ java.targetCompatibility = JavaVersion.VERSION_17
 
 repositories { mavenCentral() }
 
+// Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
+extra["kotlin-coroutines.version"] = "1.9.0"
+
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
@@ -80,6 +83,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
index 37d7a94eec0..767208a6082 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
@@ -19,6 +19,9 @@ java.targetCompatibility = JavaVersion.VERSION_17
 
 repositories { mavenCentral() }
 
+// Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
+extra["kotlin-coroutines.version"] = "1.9.0"
+
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
@@ -114,6 +117,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
index a945b87109a..98f7ba434ff 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
@@ -18,6 +18,9 @@ java.targetCompatibility = JavaVersion.VERSION_17
 
 repositories { mavenCentral() }
 
+// Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
+extra["kotlin-coroutines.version"] = "1.9.0"
+
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
@@ -69,7 +72,6 @@ dependencies {
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(projects.sentry)
   testImplementation(projects.sentrySystemTestSupport)
-  testImplementation(libs.apollo3.kotlin)
   testImplementation(libs.kotlin.test.junit)
   testImplementation(libs.slf4j2.api)
   testImplementation(libs.springboot3.starter.test) {
@@ -85,6 +87,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
index 07e61c75af8..d96c59ac871 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
@@ -2,12 +2,15 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-  alias(libs.plugins.springboot2)
-  alias(libs.plugins.spring.dependency.management)
+  java
+  application
+  alias(libs.plugins.shadow)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
 }
 
+application { mainClass.set("io.sentry.samples.spring.boot.SentryDemoApplication") }
+
 group = "io.sentry.sample.spring-boot"
 
 version = "0.0.1-SNAPSHOT"
@@ -35,6 +38,8 @@ tasks.withType<KotlinCompile>().configureEach {
 }
 
 dependencies {
+  implementation(platform(libs.springboot2.bom))
+  implementation(platform(libs.otel.instrumentation.bom))
   implementation(libs.springboot.starter)
   implementation(libs.springboot.starter.actuator)
   implementation(libs.springboot.starter.aop)
@@ -72,7 +77,27 @@ dependencies {
   testImplementation("org.apache.httpcomponents:httpclient")
 }
 
-dependencyManagement { imports { mavenBom(libs.otel.instrumentation.bom.get().toString()) } }
+val runtimeClasspath = configurations.named("runtimeClasspath")
+
+// Configure the Shadow JAR (executable JAR with all dependencies)
+tasks.shadowJar {
+  manifest { attributes["Main-Class"] = "io.sentry.samples.spring.boot.SentryDemoApplication" }
+  archiveClassifier.set("")
+
+  doLast(
+    MergeSpringMetadataAction(
+      runtimeClasspath.get(),
+      MergeSpringMetadataAction.DEFAULT_SPRING_METADATA_FILES,
+    )
+  )
+}
+
+tasks.jar {
+  enabled = false
+  dependsOn(tasks.shadowJar)
+}
+
+tasks.startScripts { dependsOn(tasks.shadowJar) }
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
@@ -80,6 +105,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
index 21a3cf3f7d5..1a7f62f6e74 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
@@ -1,14 +1,16 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.springframework.boot.gradle.tasks.run.BootRun
 
 plugins {
-  alias(libs.plugins.springboot2)
-  alias(libs.plugins.spring.dependency.management)
+  java
+  application
+  alias(libs.plugins.shadow)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
 }
 
+application { mainClass.set("io.sentry.samples.spring.boot.SentryDemoApplication") }
+
 group = "io.sentry.sample.spring-boot"
 
 version = "0.0.1-SNAPSHOT"
@@ -33,6 +35,7 @@ tasks.withType<KotlinCompile>().configureEach {
 }
 
 dependencies {
+  implementation(platform(libs.springboot2.bom))
   implementation(libs.springboot.starter)
   implementation(libs.springboot.starter.actuator)
   implementation(libs.springboot.starter.aop)
@@ -70,14 +73,35 @@ dependencies {
   testImplementation("org.apache.httpcomponents:httpclient")
 }
 
+val runtimeClasspath = configurations.named("runtimeClasspath")
+
+// Configure the Shadow JAR (executable JAR with all dependencies)
+tasks.shadowJar {
+  manifest { attributes["Main-Class"] = "io.sentry.samples.spring.boot.SentryDemoApplication" }
+  archiveClassifier.set("")
+
+  doLast(
+    MergeSpringMetadataAction(
+      runtimeClasspath.get(),
+      MergeSpringMetadataAction.DEFAULT_SPRING_METADATA_FILES,
+    )
+  )
+}
+
+tasks.jar {
+  enabled = false
+  dependsOn(tasks.shadowJar)
+}
+
+tasks.startScripts { dependsOn(tasks.shadowJar) }
+
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-tasks.register<BootRun>("bootRunWithAgent").configure {
+tasks.register<JavaExec>("bootRunWithAgent").configure {
   group = "application"
 
-  val mainBootRunTask = tasks.getByName<BootRun>("bootRun")
-  mainClass = mainBootRunTask.mainClass
-  classpath = mainBootRunTask.classpath
+  mainClass.set("io.sentry.samples.spring.boot.SentryDemoApplication")
+  classpath = sourceSets["main"].runtimeClasspath
 
   val versionName = project.properties["versionName"] as String
   val agentJarPath =
@@ -101,6 +125,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
index a45249830f4..d5b04543576 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
@@ -18,6 +18,9 @@ java.targetCompatibility = JavaVersion.VERSION_17
 
 repositories { mavenCentral() }
 
+// Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
+extra["kotlin-coroutines.version"] = "1.9.0"
+
 dependencies {
   implementation(Config.Libs.kotlinReflect)
   implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
@@ -60,6 +63,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
index 3c0a5f8c83e..b10b30737d8 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
@@ -2,12 +2,15 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-  alias(libs.plugins.springboot2)
-  alias(libs.plugins.spring.dependency.management)
+  java
+  application
+  alias(libs.plugins.shadow)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
 }
 
+application { mainClass.set("io.sentry.samples.spring.boot.SentryDemoApplication") }
+
 group = "io.sentry.sample.spring-boot"
 
 version = "0.0.1-SNAPSHOT"
@@ -19,6 +22,7 @@ java.targetCompatibility = JavaVersion.VERSION_17
 repositories { mavenCentral() }
 
 dependencies {
+  implementation(platform(libs.springboot2.bom))
   implementation(libs.springboot.starter.actuator)
   implementation(libs.springboot.starter.graphql)
   implementation(libs.springboot.starter.webflux)
@@ -42,6 +46,28 @@ dependencies {
   testImplementation("org.apache.httpcomponents:httpclient")
 }
 
+val runtimeClasspath = configurations.named("runtimeClasspath")
+
+// Configure the Shadow JAR (executable JAR with all dependencies)
+tasks.shadowJar {
+  manifest { attributes["Main-Class"] = "io.sentry.samples.spring.boot.SentryDemoApplication" }
+  archiveClassifier.set("")
+
+  doLast(
+    MergeSpringMetadataAction(
+      runtimeClasspath.get(),
+      MergeSpringMetadataAction.DEFAULT_SPRING_METADATA_FILES,
+    )
+  )
+}
+
+tasks.jar {
+  enabled = false
+  dependsOn(tasks.shadowJar)
+}
+
+tasks.startScripts { dependsOn(tasks.shadowJar) }
+
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -55,6 +81,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
index b6fcd675cf3..5b89ef568e4 100644
--- a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
@@ -2,12 +2,15 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
-  alias(libs.plugins.springboot2)
-  alias(libs.plugins.spring.dependency.management)
+  java
+  application
+  alias(libs.plugins.shadow)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
 }
 
+application { mainClass.set("io.sentry.samples.spring.boot.SentryDemoApplication") }
+
 group = "io.sentry.sample.spring-boot"
 
 version = "0.0.1-SNAPSHOT"
@@ -31,6 +34,7 @@ tasks.withType<KotlinCompile>().configureEach {
 }
 
 dependencies {
+  implementation(platform(libs.springboot2.bom))
   implementation(libs.springboot.starter)
   implementation(libs.springboot.starter.actuator)
   implementation(libs.springboot.starter.aop)
@@ -69,12 +73,41 @@ dependencies {
   testImplementation("org.apache.httpcomponents:httpclient")
 }
 
+val runtimeClasspath = configurations.named("runtimeClasspath")
+
+// Configure the Shadow JAR (executable JAR with all dependencies)
+tasks.shadowJar {
+  manifest { attributes["Main-Class"] = "io.sentry.samples.spring.boot.SentryDemoApplication" }
+  archiveClassifier.set("")
+
+  // Shadow 9.x enforces DuplicatesStrategy before transformers run, so `append`
+  // only sees one copy of each file. We merge Spring metadata from the runtime
+  // classpath and patch the built JAR in doLast.
+  doLast(
+    MergeSpringMetadataAction(
+      runtimeClasspath.get(),
+      MergeSpringMetadataAction.DEFAULT_SPRING_METADATA_FILES,
+    )
+  )
+}
+
+tasks.jar {
+  enabled = false
+  dependsOn(tasks.shadowJar)
+}
+
+tasks.startScripts { dependsOn(tasks.shadowJar) }
+
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
index 8e450865659..319431e71d2 100644
--- a/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
@@ -26,6 +26,9 @@ java.targetCompatibility = JavaVersion.VERSION_17
 
 repositories { mavenCentral() }
 
+// Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
+extra["kotlin-coroutines.version"] = "1.9.0"
+
 dependencyManagement {
   imports {
     mavenBom(SpringBootPlugin.BOM_COORDINATES)
@@ -72,6 +75,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-samples/sentry-samples-spring/build.gradle.kts b/sentry-samples/sentry-samples-spring/build.gradle.kts
index f6aa0e925ee..446baf3a696 100644
--- a/sentry-samples/sentry-samples-spring/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring/build.gradle.kts
@@ -1,9 +1,7 @@
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.springframework.boot.gradle.plugin.SpringBootPlugin.BOM_COORDINATES
 
 plugins {
   application
-  alias(libs.plugins.springboot2) apply false
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
@@ -27,9 +25,12 @@ java {
 
 repositories { mavenCentral() }
 
+// Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
+extra["kotlin-coroutines.version"] = "1.9.0"
+
 dependencyManagement {
   imports {
-    mavenBom(BOM_COORDINATES)
+    mavenBom(libs.springboot2.bom.get().toString())
     mavenBom(libs.kotlin.bom.get().toString())
     mavenBom(libs.jackson.bom.get().toString())
   }
@@ -73,6 +74,10 @@ tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
 
+  val test = project.extensions.getByType<SourceSetContainer>()["test"]
+  testClassesDirs = test.output.classesDirs
+  classpath = test.runtimeClasspath
+
   outputs.upToDateWhen { false }
 
   maxParallelForks = 1
diff --git a/sentry-spring-boot-starter/build.gradle.kts b/sentry-spring-boot-starter/build.gradle.kts
index a8b22a50f09..6b5bcdf5752 100644
--- a/sentry-spring-boot-starter/build.gradle.kts
+++ b/sentry-spring-boot-starter/build.gradle.kts
@@ -1,6 +1,5 @@
 import net.ltgt.gradle.errorprone.errorprone
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.springframework.boot.gradle.plugin.SpringBootPlugin
 
 plugins {
   `java-library`
@@ -9,7 +8,6 @@ plugins {
   jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
-  alias(libs.plugins.springboot2) apply false
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -22,7 +20,7 @@ dependencies {
   api(projects.sentrySpringBoot)
   api(libs.springboot.starter)
 
-  annotationProcessor(platform(SpringBootPlugin.BOM_COORDINATES))
+  annotationProcessor(platform(libs.springboot2.bom))
   annotationProcessor(Config.AnnotationProcessors.springBootAutoConfigure)
   annotationProcessor(Config.AnnotationProcessors.springBootConfiguration)
 
diff --git a/sentry-spring-boot/build.gradle.kts b/sentry-spring-boot/build.gradle.kts
index a81613e5e1e..43150869db5 100644
--- a/sentry-spring-boot/build.gradle.kts
+++ b/sentry-spring-boot/build.gradle.kts
@@ -1,6 +1,5 @@
 import net.ltgt.gradle.errorprone.errorprone
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.springframework.boot.gradle.plugin.SpringBootPlugin
 
 plugins {
   `java-library`
@@ -10,7 +9,6 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
-  alias(libs.plugins.springboot2) apply false
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -40,14 +38,14 @@ dependencies {
   compileOnly(libs.springboot.starter.graphql)
   compileOnly(libs.springboot.starter.quartz)
   compileOnly(libs.springboot.starter.security)
-  compileOnly(platform(SpringBootPlugin.BOM_COORDINATES))
+  compileOnly(platform(libs.springboot2.bom))
   compileOnly(Config.Libs.springWeb)
   compileOnly(Config.Libs.springWebflux)
   compileOnly(projects.sentryOpentelemetry.sentryOpentelemetryCore)
   compileOnly(projects.sentryGraphql)
   compileOnly(projects.sentryQuartz)
 
-  annotationProcessor(platform(SpringBootPlugin.BOM_COORDINATES))
+  annotationProcessor(platform(libs.springboot2.bom))
   annotationProcessor(Config.AnnotationProcessors.springBootAutoConfigure)
   annotationProcessor(Config.AnnotationProcessors.springBootConfiguration)
 
diff --git a/sentry-spring/build.gradle.kts b/sentry-spring/build.gradle.kts
index 57c0b9d9f31..b651a9e62b2 100644
--- a/sentry-spring/build.gradle.kts
+++ b/sentry-spring/build.gradle.kts
@@ -1,6 +1,5 @@
 import net.ltgt.gradle.errorprone.errorprone
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.springframework.boot.gradle.plugin.SpringBootPlugin
 
 plugins {
   `java-library`
@@ -10,7 +9,6 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
-  alias(libs.plugins.springboot2) apply false
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -22,7 +20,7 @@ tasks.withType<KotlinCompile>().configureEach {
 dependencies {
   api(projects.sentry)
 
-  compileOnly(platform(SpringBootPlugin.BOM_COORDINATES))
+  compileOnly(platform(libs.springboot2.bom))
   compileOnly(Config.Libs.springWeb)
   compileOnly(Config.Libs.springAop)
   compileOnly(Config.Libs.springSecurityWeb)
diff --git a/sentry-system-test-support/api/sentry-system-test-support.api b/sentry-system-test-support/api/sentry-system-test-support.api
deleted file mode 100644
index 83a9f288d0c..00000000000
--- a/sentry-system-test-support/api/sentry-system-test-support.api
+++ /dev/null
@@ -1,619 +0,0 @@
-public final class io/sentry/samples/graphql/AddProjectMutation : com/apollographql/apollo3/api/Mutation {
-	public static final field Companion Lio/sentry/samples/graphql/AddProjectMutation$Companion;
-	public static final field OPERATION_ID Ljava/lang/String;
-	public static final field OPERATION_NAME Ljava/lang/String;
-	public fun <init> (Ljava/lang/String;)V
-	public fun adapter ()Lcom/apollographql/apollo3/api/Adapter;
-	public final fun component1 ()Ljava/lang/String;
-	public final fun copy (Ljava/lang/String;)Lio/sentry/samples/graphql/AddProjectMutation;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/AddProjectMutation;Ljava/lang/String;ILjava/lang/Object;)Lio/sentry/samples/graphql/AddProjectMutation;
-	public fun document ()Ljava/lang/String;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getSlug ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun id ()Ljava/lang/String;
-	public fun name ()Ljava/lang/String;
-	public fun rootField ()Lcom/apollographql/apollo3/api/CompiledField;
-	public fun serializeVariables (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)V
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/AddProjectMutation$Companion {
-	public final fun getOPERATION_DOCUMENT ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/AddProjectMutation$Data : com/apollographql/apollo3/api/Mutation$Data {
-	public fun <init> (Ljava/lang/String;)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun copy (Ljava/lang/String;)Lio/sentry/samples/graphql/AddProjectMutation$Data;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/AddProjectMutation$Data;Ljava/lang/String;ILjava/lang/Object;)Lio/sentry/samples/graphql/AddProjectMutation$Data;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getAddProject ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/GreetingQuery : com/apollographql/apollo3/api/Query {
-	public static final field Companion Lio/sentry/samples/graphql/GreetingQuery$Companion;
-	public static final field OPERATION_ID Ljava/lang/String;
-	public static final field OPERATION_NAME Ljava/lang/String;
-	public fun <init> (Ljava/lang/String;)V
-	public fun adapter ()Lcom/apollographql/apollo3/api/Adapter;
-	public final fun component1 ()Ljava/lang/String;
-	public final fun copy (Ljava/lang/String;)Lio/sentry/samples/graphql/GreetingQuery;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/GreetingQuery;Ljava/lang/String;ILjava/lang/Object;)Lio/sentry/samples/graphql/GreetingQuery;
-	public fun document ()Ljava/lang/String;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getName ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun id ()Ljava/lang/String;
-	public fun name ()Ljava/lang/String;
-	public fun rootField ()Lcom/apollographql/apollo3/api/CompiledField;
-	public fun serializeVariables (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)V
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/GreetingQuery$Companion {
-	public final fun getOPERATION_DOCUMENT ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/GreetingQuery$Data : com/apollographql/apollo3/api/Query$Data {
-	public fun <init> (Ljava/lang/String;)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun copy (Ljava/lang/String;)Lio/sentry/samples/graphql/GreetingQuery$Data;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/GreetingQuery$Data;Ljava/lang/String;ILjava/lang/Object;)Lio/sentry/samples/graphql/GreetingQuery$Data;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getGreeting ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/ProjectQuery : com/apollographql/apollo3/api/Query {
-	public static final field Companion Lio/sentry/samples/graphql/ProjectQuery$Companion;
-	public static final field OPERATION_ID Ljava/lang/String;
-	public static final field OPERATION_NAME Ljava/lang/String;
-	public fun <init> (Ljava/lang/String;)V
-	public fun adapter ()Lcom/apollographql/apollo3/api/Adapter;
-	public final fun component1 ()Ljava/lang/String;
-	public final fun copy (Ljava/lang/String;)Lio/sentry/samples/graphql/ProjectQuery;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/ProjectQuery;Ljava/lang/String;ILjava/lang/Object;)Lio/sentry/samples/graphql/ProjectQuery;
-	public fun document ()Ljava/lang/String;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getSlug ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun id ()Ljava/lang/String;
-	public fun name ()Ljava/lang/String;
-	public fun rootField ()Lcom/apollographql/apollo3/api/CompiledField;
-	public fun serializeVariables (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)V
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/ProjectQuery$Companion {
-	public final fun getOPERATION_DOCUMENT ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/ProjectQuery$Data : com/apollographql/apollo3/api/Query$Data {
-	public fun <init> (Lio/sentry/samples/graphql/ProjectQuery$Project;)V
-	public final fun component1 ()Lio/sentry/samples/graphql/ProjectQuery$Project;
-	public final fun copy (Lio/sentry/samples/graphql/ProjectQuery$Project;)Lio/sentry/samples/graphql/ProjectQuery$Data;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/ProjectQuery$Data;Lio/sentry/samples/graphql/ProjectQuery$Project;ILjava/lang/Object;)Lio/sentry/samples/graphql/ProjectQuery$Data;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getProject ()Lio/sentry/samples/graphql/ProjectQuery$Project;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/ProjectQuery$Project {
-	public fun <init> (Ljava/lang/String;Ljava/lang/String;Lio/sentry/samples/graphql/type/ProjectStatus;)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun component2 ()Ljava/lang/String;
-	public final fun component3 ()Lio/sentry/samples/graphql/type/ProjectStatus;
-	public final fun copy (Ljava/lang/String;Ljava/lang/String;Lio/sentry/samples/graphql/type/ProjectStatus;)Lio/sentry/samples/graphql/ProjectQuery$Project;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/ProjectQuery$Project;Ljava/lang/String;Ljava/lang/String;Lio/sentry/samples/graphql/type/ProjectStatus;ILjava/lang/Object;)Lio/sentry/samples/graphql/ProjectQuery$Project;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getName ()Ljava/lang/String;
-	public final fun getSlug ()Ljava/lang/String;
-	public final fun getStatus ()Lio/sentry/samples/graphql/type/ProjectStatus;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/TasksAndAssigneesQuery : com/apollographql/apollo3/api/Query {
-	public static final field Companion Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Companion;
-	public static final field OPERATION_ID Ljava/lang/String;
-	public static final field OPERATION_NAME Ljava/lang/String;
-	public fun <init> (Ljava/lang/String;)V
-	public fun adapter ()Lcom/apollographql/apollo3/api/Adapter;
-	public final fun component1 ()Ljava/lang/String;
-	public final fun copy (Ljava/lang/String;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/TasksAndAssigneesQuery;Ljava/lang/String;ILjava/lang/Object;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery;
-	public fun document ()Ljava/lang/String;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getSlug ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun id ()Ljava/lang/String;
-	public fun name ()Ljava/lang/String;
-	public fun rootField ()Lcom/apollographql/apollo3/api/CompiledField;
-	public fun serializeVariables (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)V
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee {
-	public fun <init> (Ljava/lang/String;Ljava/lang/String;)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun component2 ()Ljava/lang/String;
-	public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getId ()Ljava/lang/String;
-	public final fun getName ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/TasksAndAssigneesQuery$Companion {
-	public final fun getOPERATION_DOCUMENT ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/TasksAndAssigneesQuery$Creator {
-	public fun <init> (Ljava/lang/String;Ljava/lang/String;)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun component2 ()Ljava/lang/String;
-	public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getId ()Ljava/lang/String;
-	public final fun getName ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/TasksAndAssigneesQuery$Data : com/apollographql/apollo3/api/Query$Data {
-	public fun <init> (Ljava/util/List;)V
-	public final fun component1 ()Ljava/util/List;
-	public final fun copy (Ljava/util/List;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Data;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Data;Ljava/util/List;ILjava/lang/Object;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Data;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getTasks ()Ljava/util/List;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/TasksAndAssigneesQuery$Task {
-	public fun <init> (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;Ljava/lang/String;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun component2 ()Ljava/lang/String;
-	public final fun component3 ()Ljava/lang/String;
-	public final fun component4 ()Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;
-	public final fun component5 ()Ljava/lang/String;
-	public final fun component6 ()Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;
-	public final fun copy (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;Ljava/lang/String;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Task;
-	public static synthetic fun copy$default (Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Task;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;Ljava/lang/String;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;ILjava/lang/Object;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Task;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getAssignee ()Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;
-	public final fun getAssigneeId ()Ljava/lang/String;
-	public final fun getCreator ()Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;
-	public final fun getCreatorId ()Ljava/lang/String;
-	public final fun getId ()Ljava/lang/String;
-	public final fun getName ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/samples/graphql/adapter/AddProjectMutation_ResponseAdapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/AddProjectMutation_ResponseAdapter;
-}
-
-public final class io/sentry/samples/graphql/adapter/AddProjectMutation_ResponseAdapter$Data : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/AddProjectMutation_ResponseAdapter$Data;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/AddProjectMutation$Data;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public final fun getRESPONSE_NAMES ()Ljava/util/List;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/AddProjectMutation$Data;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/AddProjectMutation_VariablesAdapter : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/AddProjectMutation_VariablesAdapter;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/AddProjectMutation;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/AddProjectMutation;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/GreetingQuery_ResponseAdapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/GreetingQuery_ResponseAdapter;
-}
-
-public final class io/sentry/samples/graphql/adapter/GreetingQuery_ResponseAdapter$Data : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/GreetingQuery_ResponseAdapter$Data;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/GreetingQuery$Data;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public final fun getRESPONSE_NAMES ()Ljava/util/List;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/GreetingQuery$Data;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/GreetingQuery_VariablesAdapter : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/GreetingQuery_VariablesAdapter;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/GreetingQuery;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/GreetingQuery;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/ProjectQuery_ResponseAdapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/ProjectQuery_ResponseAdapter;
-}
-
-public final class io/sentry/samples/graphql/adapter/ProjectQuery_ResponseAdapter$Data : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/ProjectQuery_ResponseAdapter$Data;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/ProjectQuery$Data;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public final fun getRESPONSE_NAMES ()Ljava/util/List;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/ProjectQuery$Data;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/ProjectQuery_ResponseAdapter$Project : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/ProjectQuery_ResponseAdapter$Project;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/ProjectQuery$Project;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public final fun getRESPONSE_NAMES ()Ljava/util/List;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/ProjectQuery$Project;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/ProjectQuery_VariablesAdapter : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/ProjectQuery_VariablesAdapter;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/ProjectQuery;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/ProjectQuery;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter;
-}
-
-public final class io/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter$Assignee : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter$Assignee;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public final fun getRESPONSE_NAMES ()Ljava/util/List;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Assignee;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter$Creator : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter$Creator;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public final fun getRESPONSE_NAMES ()Ljava/util/List;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Creator;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter$Data : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter$Data;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Data;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public final fun getRESPONSE_NAMES ()Ljava/util/List;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Data;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter$Task : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_ResponseAdapter$Task;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Task;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public final fun getRESPONSE_NAMES ()Ljava/util/List;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/TasksAndAssigneesQuery$Task;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_VariablesAdapter : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/adapter/TasksAndAssigneesQuery_VariablesAdapter;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/TasksAndAssigneesQuery;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/TasksAndAssigneesQuery;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/samples/graphql/selections/AddProjectMutationSelections {
-	public static final field INSTANCE Lio/sentry/samples/graphql/selections/AddProjectMutationSelections;
-	public final fun get__root ()Ljava/util/List;
-}
-
-public final class io/sentry/samples/graphql/selections/GreetingQuerySelections {
-	public static final field INSTANCE Lio/sentry/samples/graphql/selections/GreetingQuerySelections;
-	public final fun get__root ()Ljava/util/List;
-}
-
-public final class io/sentry/samples/graphql/selections/ProjectQuerySelections {
-	public static final field INSTANCE Lio/sentry/samples/graphql/selections/ProjectQuerySelections;
-	public final fun get__root ()Ljava/util/List;
-}
-
-public final class io/sentry/samples/graphql/selections/TasksAndAssigneesQuerySelections {
-	public static final field INSTANCE Lio/sentry/samples/graphql/selections/TasksAndAssigneesQuerySelections;
-	public final fun get__root ()Ljava/util/List;
-}
-
-public final class io/sentry/samples/graphql/type/Assignee {
-	public static final field Companion Lio/sentry/samples/graphql/type/Assignee$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/Assignee$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/ObjectType;
-}
-
-public final class io/sentry/samples/graphql/type/Creator {
-	public static final field Companion Lio/sentry/samples/graphql/type/Creator$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/Creator$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/ObjectType;
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLBoolean {
-	public static final field Companion Lio/sentry/samples/graphql/type/GraphQLBoolean$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLBoolean$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/CustomScalarType;
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLFloat {
-	public static final field Companion Lio/sentry/samples/graphql/type/GraphQLFloat$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLFloat$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/CustomScalarType;
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLID {
-	public static final field Companion Lio/sentry/samples/graphql/type/GraphQLID$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLID$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/CustomScalarType;
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLInt {
-	public static final field Companion Lio/sentry/samples/graphql/type/GraphQLInt$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLInt$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/CustomScalarType;
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLString {
-	public static final field Companion Lio/sentry/samples/graphql/type/GraphQLString$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/GraphQLString$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/CustomScalarType;
-}
-
-public final class io/sentry/samples/graphql/type/Mutation {
-	public static final field Companion Lio/sentry/samples/graphql/type/Mutation$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/Mutation$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/ObjectType;
-}
-
-public final class io/sentry/samples/graphql/type/Project {
-	public static final field Companion Lio/sentry/samples/graphql/type/Project$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/Project$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/ObjectType;
-}
-
-public final class io/sentry/samples/graphql/type/ProjectStatus : java/lang/Enum {
-	public static final field ACTIVE Lio/sentry/samples/graphql/type/ProjectStatus;
-	public static final field ATTIC Lio/sentry/samples/graphql/type/ProjectStatus;
-	public static final field COMMUNITY Lio/sentry/samples/graphql/type/ProjectStatus;
-	public static final field Companion Lio/sentry/samples/graphql/type/ProjectStatus$Companion;
-	public static final field EOL Lio/sentry/samples/graphql/type/ProjectStatus;
-	public static final field INCUBATING Lio/sentry/samples/graphql/type/ProjectStatus;
-	public static final field UNKNOWN__ Lio/sentry/samples/graphql/type/ProjectStatus;
-	public static fun getEntries ()Lkotlin/enums/EnumEntries;
-	public final fun getRawValue ()Ljava/lang/String;
-	public static fun valueOf (Ljava/lang/String;)Lio/sentry/samples/graphql/type/ProjectStatus;
-	public static fun values ()[Lio/sentry/samples/graphql/type/ProjectStatus;
-}
-
-public final class io/sentry/samples/graphql/type/ProjectStatus$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/EnumType;
-	public final fun knownValues ()[Lio/sentry/samples/graphql/type/ProjectStatus;
-	public final fun safeValueOf (Ljava/lang/String;)Lio/sentry/samples/graphql/type/ProjectStatus;
-}
-
-public final class io/sentry/samples/graphql/type/Query {
-	public static final field Companion Lio/sentry/samples/graphql/type/Query$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/Query$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/ObjectType;
-}
-
-public final class io/sentry/samples/graphql/type/Task {
-	public static final field Companion Lio/sentry/samples/graphql/type/Task$Companion;
-	public fun <init> ()V
-}
-
-public final class io/sentry/samples/graphql/type/Task$Companion {
-	public final fun getType ()Lcom/apollographql/apollo3/api/ObjectType;
-}
-
-public final class io/sentry/samples/graphql/type/adapter/ProjectStatus_ResponseAdapter : com/apollographql/apollo3/api/Adapter {
-	public static final field INSTANCE Lio/sentry/samples/graphql/type/adapter/ProjectStatus_ResponseAdapter;
-	public fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Lio/sentry/samples/graphql/type/ProjectStatus;
-	public synthetic fun fromJson (Lcom/apollographql/apollo3/api/json/JsonReader;Lcom/apollographql/apollo3/api/CustomScalarAdapters;)Ljava/lang/Object;
-	public fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Lio/sentry/samples/graphql/type/ProjectStatus;)V
-	public synthetic fun toJson (Lcom/apollographql/apollo3/api/json/JsonWriter;Lcom/apollographql/apollo3/api/CustomScalarAdapters;Ljava/lang/Object;)V
-}
-
-public final class io/sentry/systemtest/Person {
-	public fun <init> (Ljava/lang/String;Ljava/lang/String;)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun component2 ()Ljava/lang/String;
-	public final fun copy (Ljava/lang/String;Ljava/lang/String;)Lio/sentry/systemtest/Person;
-	public static synthetic fun copy$default (Lio/sentry/systemtest/Person;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Lio/sentry/systemtest/Person;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getFirstName ()Ljava/lang/String;
-	public final fun getLastName ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/systemtest/Todo {
-	public fun <init> (JLjava/lang/String;Z)V
-	public final fun component1 ()J
-	public final fun component2 ()Ljava/lang/String;
-	public final fun component3 ()Z
-	public final fun copy (JLjava/lang/String;Z)Lio/sentry/systemtest/Todo;
-	public static synthetic fun copy$default (Lio/sentry/systemtest/Todo;JLjava/lang/String;ZILjava/lang/Object;)Lio/sentry/systemtest/Todo;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getCompleted ()Z
-	public final fun getId ()J
-	public final fun getTitle ()Ljava/lang/String;
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/systemtest/graphql/GraphqlTestClient {
-	public fun <init> (Ljava/lang/String;)V
-	public final fun addProject (Ljava/lang/String;)Lcom/apollographql/apollo3/api/ApolloResponse;
-	public final fun getApollo ()Lcom/apollographql/apollo3/ApolloClient;
-	public final fun greet (Ljava/lang/String;)Lcom/apollographql/apollo3/api/ApolloResponse;
-	public final fun project (Ljava/lang/String;)Lcom/apollographql/apollo3/api/ApolloResponse;
-	public final fun tasksAndAssignees (Ljava/lang/String;)Lcom/apollographql/apollo3/api/ApolloResponse;
-}
-
-public final class io/sentry/systemtest/util/EnvelopeCounts {
-	public fun <init> ()V
-	public final fun getEnvelopes ()Ljava/lang/Long;
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/systemtest/util/EnvelopesReceived {
-	public fun <init> ()V
-	public final fun getEnvelopes ()Ljava/util/List;
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class io/sentry/systemtest/util/FeatureFlagResponse {
-	public fun <init> (Ljava/lang/String;Z)V
-	public final fun component1 ()Ljava/lang/String;
-	public final fun component2 ()Z
-	public final fun copy (Ljava/lang/String;Z)Lio/sentry/systemtest/util/FeatureFlagResponse;
-	public static synthetic fun copy$default (Lio/sentry/systemtest/util/FeatureFlagResponse;Ljava/lang/String;ZILjava/lang/Object;)Lio/sentry/systemtest/util/FeatureFlagResponse;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getFlagKey ()Ljava/lang/String;
-	public final fun getValue ()Z
-	public fun hashCode ()I
-	public fun toString ()Ljava/lang/String;
-}
-
-public class io/sentry/systemtest/util/LoggingInsecureRestClient {
-	public fun <init> ()V
-	protected final fun call (Lokhttp3/Request$Builder;ZLjava/util/Map;)Lokhttp3/Response;
-	public static synthetic fun call$default (Lio/sentry/systemtest/util/LoggingInsecureRestClient;Lokhttp3/Request$Builder;ZLjava/util/Map;ILjava/lang/Object;)Lokhttp3/Response;
-	protected final fun client ()Lokhttp3/OkHttpClient;
-	public final fun getLastKnownStatusCode ()Ljava/lang/Integer;
-	public final fun getLogger ()Lorg/slf4j/Logger;
-	protected final fun objectMapper ()Lcom/fasterxml/jackson/databind/ObjectMapper;
-	public final fun setLastKnownStatusCode (Ljava/lang/Integer;)V
-	protected final fun toRequestBody (Ljava/lang/Object;)Lokhttp3/RequestBody;
-}
-
-public final class io/sentry/systemtest/util/RestTestClient : io/sentry/systemtest/util/LoggingInsecureRestClient {
-	public fun <init> (Ljava/lang/String;)V
-	public final fun checkFeatureFlag (Ljava/lang/String;)Lio/sentry/systemtest/util/FeatureFlagResponse;
-	public final fun createPerson (Lio/sentry/systemtest/Person;Ljava/util/Map;)Lio/sentry/systemtest/Person;
-	public static synthetic fun createPerson$default (Lio/sentry/systemtest/util/RestTestClient;Lio/sentry/systemtest/Person;Ljava/util/Map;ILjava/lang/Object;)Lio/sentry/systemtest/Person;
-	public final fun createPersonDistributedTracing (Lio/sentry/systemtest/Person;Ljava/util/Map;)Lio/sentry/systemtest/Person;
-	public static synthetic fun createPersonDistributedTracing$default (Lio/sentry/systemtest/util/RestTestClient;Lio/sentry/systemtest/Person;Ljava/util/Map;ILjava/lang/Object;)Lio/sentry/systemtest/Person;
-	public final fun deleteCachedTodo (J)V
-	public final fun errorWithFeatureFlag (Ljava/lang/String;)Ljava/lang/String;
-	public final fun getCachedTodo (J)Lio/sentry/systemtest/Todo;
-	public final fun getCountMetric ()Ljava/lang/String;
-	public final fun getDistributionMetric (J)Ljava/lang/String;
-	public final fun getGaugeMetric (J)Ljava/lang/String;
-	public final fun getPerson (J)Lio/sentry/systemtest/Person;
-	public final fun getPersonDistributedTracing (JLjava/util/Map;)Lio/sentry/systemtest/Person;
-	public static synthetic fun getPersonDistributedTracing$default (Lio/sentry/systemtest/util/RestTestClient;JLjava/util/Map;ILjava/lang/Object;)Lio/sentry/systemtest/Person;
-	public final fun getTodo (J)Lio/sentry/systemtest/Todo;
-	public final fun getTodoRestClient (J)Lio/sentry/systemtest/Todo;
-	public final fun getTodoWebclient (J)Lio/sentry/systemtest/Todo;
-	public final fun saveCachedTodo (Lio/sentry/systemtest/Todo;)Lio/sentry/systemtest/Todo;
-}
-
-public final class io/sentry/systemtest/util/SentryMockServerClient : io/sentry/systemtest/util/LoggingInsecureRestClient {
-	public fun <init> (Ljava/lang/String;)V
-	public final fun getEnvelopeCount ()Lio/sentry/systemtest/util/EnvelopeCounts;
-	public final fun getEnvelopes ()Lio/sentry/systemtest/util/EnvelopesReceived;
-	public final fun reset ()V
-}
-
-public final class io/sentry/systemtest/util/TestHelper {
-	public fun <init> (Ljava/lang/String;)V
-	public final fun doesContainLogWithBody (Lio/sentry/SentryLogEvents;Ljava/lang/String;)Z
-	public final fun doesContainMetric (Lio/sentry/SentryMetricsEvents;Ljava/lang/String;Ljava/lang/String;DLjava/lang/String;)Z
-	public static synthetic fun doesContainMetric$default (Lio/sentry/systemtest/util/TestHelper;Lio/sentry/SentryMetricsEvents;Ljava/lang/String;Ljava/lang/String;DLjava/lang/String;ILjava/lang/Object;)Z
-	public final fun doesEventHaveExceptionMessage (Lio/sentry/SentryEvent;Ljava/lang/String;)Z
-	public final fun doesEventHaveFlag (Lio/sentry/SentryEvent;Ljava/lang/String;Z)Z
-	public final fun doesLogWithBodyHaveAttribute (Lio/sentry/SentryLogEvents;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)Z
-	public final fun doesMetricHaveAttribute (Lio/sentry/SentryMetricsEvents;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)Z
-	public final fun doesTransactionContainSpanWithDescription (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;)Z
-	public final fun doesTransactionContainSpanWithOp (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;)Z
-	public final fun doesTransactionContainSpanWithOpAndDescription (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;Ljava/lang/String;)Z
-	public final fun doesTransactionHave (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;Lio/sentry/protocol/FeatureFlag;)Z
-	public static synthetic fun doesTransactionHave$default (Lio/sentry/systemtest/util/TestHelper;Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;Lio/sentry/protocol/FeatureFlag;ILjava/lang/Object;)Z
-	public final fun doesTransactionHaveOp (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;)Z
-	public final fun doesTransactionHaveSpanWith (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;Lio/sentry/protocol/FeatureFlag;Z)Z
-	public static synthetic fun doesTransactionHaveSpanWith$default (Lio/sentry/systemtest/util/TestHelper;Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;Lio/sentry/protocol/FeatureFlag;ZILjava/lang/Object;)Z
-	public final fun doesTransactionHaveTraceId (Lio/sentry/protocol/SentryTransaction;Ljava/lang/String;)Z
-	public final fun ensureEnvelopeCountIncreased ()V
-	public final fun ensureEnvelopeReceived (ILkotlin/jvm/functions/Function1;)V
-	public static synthetic fun ensureEnvelopeReceived$default (Lio/sentry/systemtest/util/TestHelper;ILkotlin/jvm/functions/Function1;ILjava/lang/Object;)V
-	public final fun ensureErrorCount (Lcom/apollographql/apollo3/api/ApolloResponse;I)V
-	public final fun ensureErrorReceived (Lkotlin/jvm/functions/Function1;)V
-	public final fun ensureLogsReceived (Lkotlin/jvm/functions/Function2;)V
-	public final fun ensureMetricsReceived (Lkotlin/jvm/functions/Function2;)V
-	public final fun ensureNoEnvelopeReceived (Lkotlin/jvm/functions/Function1;)V
-	public final fun ensureNoErrors (Lcom/apollographql/apollo3/api/ApolloResponse;)V
-	public final fun ensureNoTransactionReceived (Lkotlin/jvm/functions/Function2;)V
-	public final fun ensureProfileChunkReceived (Lkotlin/jvm/functions/Function2;)V
-	public final fun ensureTransactionReceived (Lkotlin/jvm/functions/Function2;)V
-	public final fun ensureTransactionWithSpanReceived (Lkotlin/jvm/functions/Function1;)V
-	public final fun findJar (Ljava/lang/String;Ljava/lang/String;)Ljava/io/File;
-	public static synthetic fun findJar$default (Lio/sentry/systemtest/util/TestHelper;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Ljava/io/File;
-	public final fun getDsn ()Ljava/lang/String;
-	public final fun getEnvelopeCounts ()Lio/sentry/systemtest/util/EnvelopeCounts;
-	public final fun getGraphqlClient ()Lio/sentry/systemtest/graphql/GraphqlTestClient;
-	public final fun getJsonSerializer ()Lio/sentry/JsonSerializer;
-	public final fun getRestClient ()Lio/sentry/systemtest/util/RestTestClient;
-	public final fun getSentryClient ()Lio/sentry/systemtest/util/SentryMockServerClient;
-	public final fun launch (Ljava/io/File;Ljava/util/Map;Z)Ljava/lang/Process;
-	public static synthetic fun launch$default (Lio/sentry/systemtest/util/TestHelper;Ljava/io/File;Ljava/util/Map;ZILjava/lang/Object;)Ljava/lang/Process;
-	public final fun logObject (Ljava/lang/Object;)V
-	public final fun reset ()V
-	public final fun setEnvelopeCounts (Lio/sentry/systemtest/util/EnvelopeCounts;)V
-	public final fun snapshotEnvelopeCount ()V
-}
-
diff --git a/sentry-system-test-support/build.gradle.kts b/sentry-system-test-support/build.gradle.kts
index dea680b4db1..b8e4a283c87 100644
--- a/sentry-system-test-support/build.gradle.kts
+++ b/sentry-system-test-support/build.gradle.kts
@@ -5,7 +5,7 @@ plugins {
   jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
-  id("com.apollographql.apollo3") version "3.8.2"
+  id("com.apollographql.apollo") version "4.1.1"
 }
 
 configure<JavaPluginExtension> {
@@ -22,7 +22,7 @@ tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach
 dependencies {
   api(projects.sentry)
   api(projects.sentryTestSupport)
-  api(libs.apollo3.kotlin)
+  api(libs.apollo4.kotlin)
 
   compileOnly(libs.jetbrains.annotations)
   compileOnly(libs.nopen.annotations)
diff --git a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/graphql/GraphqlTestClient.kt b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/graphql/GraphqlTestClient.kt
index 5127f06b8f7..c1b0a409bda 100644
--- a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/graphql/GraphqlTestClient.kt
+++ b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/graphql/GraphqlTestClient.kt
@@ -1,9 +1,9 @@
 package io.sentry.systemtest.graphql
 
-import com.apollographql.apollo3.ApolloClient
-import com.apollographql.apollo3.api.ApolloResponse
-import com.apollographql.apollo3.api.Mutation
-import com.apollographql.apollo3.api.Query
+import com.apollographql.apollo.ApolloClient
+import com.apollographql.apollo.api.ApolloResponse
+import com.apollographql.apollo.api.Mutation
+import com.apollographql.apollo.api.Query
 import io.sentry.samples.graphql.AddProjectMutation
 import io.sentry.samples.graphql.GreetingQuery
 import io.sentry.samples.graphql.ProjectQuery
diff --git a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/TestHelper.kt b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/TestHelper.kt
index 19817c34ac8..7f0dfc8c955 100644
--- a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/TestHelper.kt
+++ b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/TestHelper.kt
@@ -1,7 +1,7 @@
 package io.sentry.systemtest.util
 
-import com.apollographql.apollo3.api.ApolloResponse
-import com.apollographql.apollo3.api.Operation
+import com.apollographql.apollo.api.ApolloResponse
+import com.apollographql.apollo.api.Operation
 import io.sentry.JsonSerializer
 import io.sentry.ProfileChunk
 import io.sentry.SentryEnvelopeHeader
diff --git a/sentry-test-support/api/sentry-test-support.api b/sentry-test-support/api/sentry-test-support.api
deleted file mode 100644
index 1d8ae671216..00000000000
--- a/sentry-test-support/api/sentry-test-support.api
+++ /dev/null
@@ -1,75 +0,0 @@
-public final class io/sentry/AssertionsKt {
-	public static final fun assertEnvelopeEvent (Ljava/util/List;Lio/sentry/ILogger;Lkotlin/jvm/functions/Function2;)Lio/sentry/SentryEvent;
-	public static synthetic fun assertEnvelopeEvent$default (Ljava/util/List;Lio/sentry/ILogger;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lio/sentry/SentryEvent;
-	public static final fun assertEnvelopeFeedback (Ljava/util/List;Lio/sentry/ILogger;Lkotlin/jvm/functions/Function2;)Lio/sentry/SentryEvent;
-	public static synthetic fun assertEnvelopeFeedback$default (Ljava/util/List;Lio/sentry/ILogger;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lio/sentry/SentryEvent;
-	public static final fun assertEnvelopeProfile (Ljava/util/List;Lio/sentry/ILogger;Lkotlin/jvm/functions/Function2;)Lio/sentry/ProfilingTraceData;
-	public static synthetic fun assertEnvelopeProfile$default (Ljava/util/List;Lio/sentry/ILogger;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lio/sentry/ProfilingTraceData;
-	public static final fun assertEnvelopeTransaction (Ljava/util/List;Lio/sentry/ILogger;Lkotlin/jvm/functions/Function2;)Lio/sentry/protocol/SentryTransaction;
-	public static synthetic fun assertEnvelopeTransaction$default (Ljava/util/List;Lio/sentry/ILogger;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lio/sentry/protocol/SentryTransaction;
-	public static final fun checkEvent (Lkotlin/jvm/functions/Function1;)Lio/sentry/SentryEnvelope;
-	public static final fun checkLogs (Lkotlin/jvm/functions/Function1;)Lio/sentry/SentryEnvelope;
-	public static final fun checkTransaction (Lkotlin/jvm/functions/Function1;)Lio/sentry/SentryEnvelope;
-	public static final fun getMockServerRequestTimeoutMillis ()J
-}
-
-public final class io/sentry/SkipError : java/lang/Error {
-	public fun <init> (Ljava/lang/String;)V
-}
-
-public final class io/sentry/test/DeferredExecutorService : io/sentry/ISentryExecutorService {
-	public fun <init> ()V
-	public fun close (J)V
-	public final fun hasScheduledRunnables ()Z
-	public fun isClosed ()Z
-	public fun prewarm ()V
-	public final fun runAll ()V
-	public fun schedule (Ljava/lang/Runnable;J)Ljava/util/concurrent/Future;
-	public fun submit (Ljava/lang/Runnable;)Ljava/util/concurrent/Future;
-	public fun submit (Ljava/util/concurrent/Callable;)Ljava/util/concurrent/Future;
-}
-
-public final class io/sentry/test/ImmediateExecutorService : io/sentry/ISentryExecutorService {
-	public fun <init> ()V
-	public fun close (J)V
-	public fun isClosed ()Z
-	public fun prewarm ()V
-	public fun schedule (Ljava/lang/Runnable;J)Ljava/util/concurrent/Future;
-	public fun submit (Ljava/lang/Runnable;)Ljava/util/concurrent/Future;
-	public fun submit (Ljava/util/concurrent/Callable;)Ljava/util/concurrent/Future;
-}
-
-public final class io/sentry/test/InitKt {
-	public static final fun applyTestOptions (Lio/sentry/SentryOptions;)V
-	public static final fun initForTest ()V
-	public static final fun initForTest (Lio/sentry/Sentry$OptionsConfiguration;)V
-	public static final fun initForTest (Lio/sentry/Sentry$OptionsConfiguration;Z)V
-	public static final fun initForTest (Lio/sentry/SentryOptions;)V
-	public static final fun initForTest (Ljava/lang/String;)V
-}
-
-public final class io/sentry/test/MocksKt {
-	public static final fun createSentryClientMock (Z)Lio/sentry/ISentryClient;
-	public static synthetic fun createSentryClientMock$default (ZILjava/lang/Object;)Lio/sentry/ISentryClient;
-	public static final fun createTestScopes (Lio/sentry/SentryOptions;ZLio/sentry/IScope;Lio/sentry/IScope;Lio/sentry/IScope;)Lio/sentry/Scopes;
-	public static synthetic fun createTestScopes$default (Lio/sentry/SentryOptions;ZLio/sentry/IScope;Lio/sentry/IScope;Lio/sentry/IScope;ILjava/lang/Object;)Lio/sentry/Scopes;
-}
-
-public final class io/sentry/test/NonOverridableNoOpSentryExecutorService : io/sentry/ISentryExecutorService {
-	public fun <init> ()V
-	public fun close (J)V
-	public fun isClosed ()Z
-	public fun prewarm ()V
-	public fun schedule (Ljava/lang/Runnable;J)Ljava/util/concurrent/Future;
-	public fun submit (Ljava/lang/Runnable;)Ljava/util/concurrent/Future;
-	public fun submit (Ljava/util/concurrent/Callable;)Ljava/util/concurrent/Future;
-}
-
-public final class io/sentry/test/ReflectionKt {
-	public static final fun collectInterfaceHierarchy (Ljava/lang/Class;)Ljava/util/List;
-	public static final fun containsMethod (Ljava/lang/Class;Ljava/lang/String;Ljava/lang/Class;)Z
-	public static final fun containsMethod (Ljava/lang/Class;Ljava/lang/String;[Ljava/lang/Class;)Z
-	public static final fun getCtor (Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Constructor;
-	public static final fun getDeclaredCtor (Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Constructor;
-}
-
diff --git a/test/system-test-runner.py b/test/system-test-runner.py
index 70489c580a5..1250c6cbab9 100644
--- a/test/system-test-runner.py
+++ b/test/system-test-runner.py
@@ -326,7 +326,7 @@ def start_tomcat_server(self, sample_module: str) -> None:
             # Start the Tomcat server
             with open("tomcat-server.txt", "w") as log_file:
                 self.tomcat_server.process = subprocess.Popen(
-                    ["./gradlew", f"sentry-samples:{sample_module}:run"],
+                    ["./gradlew", f"sentry-samples:{sample_module}:run", "--console=plain"],
                     env=env,
                     stdout=log_file,
                     stderr=subprocess.STDOUT
@@ -406,6 +406,8 @@ def wait_for_spring(self, max_attempts: int = 20) -> bool:
         print("Waiting for Spring application to be ready...")
 
         for attempt in range(1, max_attempts + 1):
+            # All current Spring Boot samples expose actuator/health. Waiting for the
+            # health endpoint avoids false positives from unrelated services on 8080.
             try:
                 response = requests.head(
                     "http://localhost:8080/actuator/health",
@@ -528,18 +530,23 @@ def stop_spring_server(self) -> None:
             # Clean up PID file and instance variable
             cleanup_pid(self.spring_server)
 
-    def get_build_task(self, server_type: Optional[ServerType]) -> str:
+    def get_build_task(self, sample_module: str, server_type: Optional[ServerType]) -> str:
         """Get the appropriate build task for a module."""
         if server_type == ServerType.TOMCAT:
             return "war"
         elif server_type == ServerType.SPRING:
+            # Modules using Shadow plugin (e.g. Spring Boot 2 samples) use shadowJar,
+            # modules using Spring Boot plugin (SB3/SB4 samples) use bootJar
+            build_file = Path(f"sentry-samples/{sample_module}/build.gradle.kts")
+            if build_file.exists() and "shadow" in build_file.read_text():
+                return "shadowJar"
             return "bootJar"
 
         return "assemble"
 
     def build_module(self, sample_module: str, server_type: Optional[ServerType]) -> int:
         """Build a sample module using the appropriate task."""
-        build_task = self.get_build_task(server_type)
+        build_task = self.get_build_task(sample_module, server_type)
         print(f"Building {sample_module} using {build_task} task")
         return self.run_gradle_task(f":sentry-samples:{sample_module}:{build_task}")
 
@@ -547,7 +554,7 @@ def run_gradle_task(self, task: str) -> int:
         """Run a Gradle task and return the exit code."""
         print(f"Running: ./gradlew {task}")
         try:
-            result = subprocess.run(["./gradlew", task], check=False)
+            result = subprocess.run(["./gradlew", task, "--console=plain"], check=False)
             return result.returncode
         except Exception as e:
             print(f"Failed to run Gradle task: {e}")

From de6a178ca26079db56d6b52388281e87621c91df Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 16 Apr 2026 14:35:13 +0200
Subject: [PATCH 101/391] fix(gestures): Replace GestureDetectorCompat with
 lightweight detector to fix ANR (#5138)

* fix(android): Replace GestureDetectorCompat with lightweight SentryGestureDetector to fix ANR

GestureDetectorCompat internally uses Handler.sendMessage/removeMessages which
acquires a synchronized lock on the main thread MessageQueue, plus
recordGestureClassification triggers IPC calls. This caused ANRs under load
(SDK-CRASHES-JAVA-596, 175K+ occurrences).

Replace with a minimal custom detector that only detects click, scroll, and
fling without any Handler scheduling, MessageQueue contention, or IPC overhead.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* test(android): Add unit tests for SentryGestureDetector

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(gestures): Clear VelocityTracker on ACTION_DOWN to prevent stale velocity data

Matches GestureDetector behavior: if consecutive ACTION_DOWN events
arrive without an intervening ACTION_UP/ACTION_CANCEL, stale motion
data could bleed into fling detection.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(gestures): Remove stale GestureDetectorCompat class availability check

UserInteractionIntegration gated itself on GestureDetectorCompat being
available via classloader check, but SentryGestureDetector only uses
Android SDK classes. Remove the check so the integration works without
androidx.core. Also remove the stale proguard -keep rule.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Move changelog entry

* ref(gestures): Simplify SentryGestureDetector resource lifecycle

Keep VelocityTracker alive across gesture cycles instead of
obtain/recycle churn on every gesture. Add release() method called
from SentryWindowCallback.stopTracking() to prevent native resource
leaks when activity is destroyed mid-gesture. Also fix broken Javadoc
@link to removed dependency, change onTouchEvent return to void, and
remove redundant null check.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(gestures): Handle multi-touch to prevent spurious tap detection

When a second finger touches the screen (ACTION_POINTER_DOWN), cancel
tap detection by setting isInTapRegion to false. Previously, pinch-to-zoom
gestures where the first finger stayed still would incorrectly trigger
onSingleTapUp, producing false click breadcrumbs.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore: Register btrace-perfetto skill in agents.toml

Add local btrace-perfetto skill for capturing and comparing Perfetto
traces on Android devices using btrace 3.0.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore: Add btrace-perfetto skill for Perfetto trace capture

Workflow skill that automates capturing and comparing Perfetto traces
using btrace 3.0 on Android devices. Includes a Perfetto UI viewer
template with SQL query deep-linking via postMessage API.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore: Update btrace skill with release builds and sound cues

Use release builds for accurate profiling, add ProGuard keep rules
for btrace and Sentry class names, increase trace duration to 30s,
and play a Ping sound synced to the actual trace start.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore: Update btrace-perfetto skill with debug builds and trace comparison

Prefer debug builds for richer tracing instrumentation (Handler,
MessageQueue, Lock slices). Add trace_processor prerequisite for local
querying. Add Step 6 with SQL queries and comparison table generation.
Include sampling rate reference and additional troubleshooting entries.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(gestures): Suppress fling after multi-touch to prevent misclassified swipes

The ACTION_POINTER_DOWN handler suppressed taps but not flings. When
the last finger lifts quickly after a pinch-to-zoom, the velocity check
in ACTION_UP could fire onFling, causing SentryGestureListener to
misclassify the gesture as a swipe breadcrumb.

Add ignoreUpEvent flag mirroring GestureDetector's mIgnoreNextUpEvent
to skip the entire UP handler after multi-touch.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .claude/skills/.gitignore                     |   2 +
 .claude/skills/btrace-perfetto/SKILL.md       | 284 +++++++++++++
 .../assets/viewer-template.html               |  49 +++
 CHANGELOG.md                                  |   4 +
 agents.toml                                   |   4 +
 sentry-android-core/proguard-rules.pro        |   1 -
 .../core/UserInteractionIntegration.java      |  33 +-
 .../gestures/SentryGestureDetector.java       | 147 +++++++
 .../gestures/SentryWindowCallback.java        |  10 +-
 .../core/UserInteractionIntegrationTest.kt    |  17 -
 .../gestures/SentryGestureDetectorTest.kt     | 386 ++++++++++++++++++
 .../gestures/SentryWindowCallbackTest.kt      |   3 +-
 12 files changed, 892 insertions(+), 48 deletions(-)
 create mode 100644 .claude/skills/btrace-perfetto/SKILL.md
 create mode 100644 .claude/skills/btrace-perfetto/assets/viewer-template.html
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureDetector.java
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureDetectorTest.kt

diff --git a/.claude/skills/.gitignore b/.claude/skills/.gitignore
index 08243027e52..229f4495ee3 100644
--- a/.claude/skills/.gitignore
+++ b/.claude/skills/.gitignore
@@ -6,3 +6,5 @@
 !create-java-pr/**
 !test/
 !test/**
+!btrace-perfetto/
+!btrace-perfetto/**
diff --git a/.claude/skills/btrace-perfetto/SKILL.md b/.claude/skills/btrace-perfetto/SKILL.md
new file mode 100644
index 00000000000..7cbea4841ee
--- /dev/null
+++ b/.claude/skills/btrace-perfetto/SKILL.md
@@ -0,0 +1,284 @@
+---
+name: btrace-perfetto
+description: Capture and compare Perfetto traces using btrace 3.0 on an Android device. Use when asked to "profile", "capture trace", "perfetto trace", "btrace", "compare traces", "record perfetto", "trace touch events", "measure performance on device", or benchmark Android SDK changes between branches.
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep, WebFetch, AskUserQuestion
+argument-hint: "[branch1] [branch2] [duration] [sql-query]"
+---
+
+# btrace Perfetto Trace Capture
+
+Capture Perfetto traces with btrace 3.0 on a connected Android device, optionally comparing two branches. Opens results in Perfetto UI with a prefilled SQL query. After capture, query traces locally with `trace_processor` to compute comparison stats.
+
+## Prerequisites
+
+Before starting, verify:
+
+1. **Connected device**: `adb devices` shows a device (Android 8.0+, 64-bit)
+2. **btrace CLI jar**: Check if `tools/btrace/rhea-trace-shell.jar` exists. If not, download it:
+   ```bash
+   mkdir -p tools/btrace/traces
+   curl -sL "https://repo1.maven.org/maven2/com/bytedance/btrace/rhea-trace-processor/3.0.0/rhea-trace-processor-3.0.0.jar" \
+     -o tools/btrace/rhea-trace-shell.jar
+   ```
+3. **Perfetto trace_processor**: Check if `/tmp/trace_processor` exists. If not, download it:
+   ```bash
+   curl -sL "https://get.perfetto.dev/trace_processor" -o /tmp/trace_processor && chmod +x /tmp/trace_processor
+   ```
+4. **Device ABI**: Run `adb shell getprop ro.product.cpu.abi` — btrace only supports arm64-v8a and armeabi-v7a (no x86/x86_64)
+
+## Step 1: Parse Arguments
+
+| Argument | Default | Description |
+|----------|---------|-------------|
+| branch1 | current branch | First branch to trace |
+| branch2 | `main` | Second branch to compare against |
+| duration | `30` | Trace duration in seconds |
+| sql-query | see below | SQL query to prefill in Perfetto UI |
+
+If no arguments are provided, ask the user what they want to trace and which branches to compare. If only one branch is given, capture only that branch (no comparison).
+
+## Step 2: Integrate btrace into Sample App
+
+The sample app is at `sentry-samples/sentry-samples-android/`.
+
+### 2a: Add btrace dependency
+
+In `sentry-samples/sentry-samples-android/build.gradle.kts`, add to the `dependencies` block:
+
+```kotlin
+implementation("com.bytedance.btrace:rhea-inhouse:3.0.0")
+```
+
+### 2b: Restrict ABI to device architecture
+
+The btrace native library (shadowhook) does not support x86/x86_64. Replace the `ndk` abiFilters line in `defaultConfig` to match the connected device:
+
+```kotlin
+ndk { abiFilters.addAll(listOf("arm64-v8a")) }
+```
+
+Adjust if the device reports a different ABI.
+
+### 2c: Initialize btrace in Application
+
+In `MyApplication.java`, add `attachBaseContext`:
+
+```java
+import android.content.Context;
+import com.bytedance.rheatrace.RheaTrace3;
+
+// Add before onCreate:
+@Override
+protected void attachBaseContext(Context base) {
+    super.attachBaseContext(base);
+    RheaTrace3.init(base);
+}
+```
+
+**Important**: The package is `com.bytedance.rheatrace`, not `com.bytedance.btrace`.
+
+### 2d: Add ProGuard keep rules (release builds only)
+
+Only needed when building release. In `sentry-samples/sentry-samples-android/proguard-rules.pro`, add:
+
+```
+-keep class com.bytedance.rheatrace.** { *; }
+-keepnames class io.sentry.** { *; }
+```
+
+The first rule prevents R8 from stripping btrace's HTTP server classes (fails with `SocketException` otherwise). The second preserves Sentry class and method names so they appear readable in the Perfetto trace instead of obfuscated single-letter names.
+
+## Step 3: Build and Install
+
+Prefer **debug builds** — they provide richer tracing instrumentation (Handler, MessageQueue, Monitor:Lock slices visible) which is essential for comparing internal SDK behavior. Use the default 1kHz btrace sampling rate for debug builds.
+
+```bash
+./gradlew :sentry-samples:sentry-samples-android:installDebug
+```
+
+**Release builds** are useful when you need to measure real-world performance without StrictMode/debuggable overhead or with R8 optimizations. Require the ProGuard keep rules from step 2d. Use `-sampleInterval 333000` (333μs / 3kHz) for finer granularity since release code runs faster.
+
+```bash
+./gradlew :sentry-samples:sentry-samples-android:installRelease
+```
+
+## Step 4: Capture Trace
+
+For each branch to trace:
+
+### 4a: Set btrace properties and launch app
+
+Clear any stale port files, set properties, and launch:
+
+```bash
+adb shell "rm -rf /storage/emulated/0/Android/data/io.sentry.samples.android/files/rhea-port"
+adb shell setprop debug.rhea3.startWhenAppLaunch 1
+adb shell setprop debug.rhea3.waitTraceTimeout 60
+adb shell am force-stop io.sentry.samples.android
+sleep 2
+adb shell am start -n io.sentry.samples.android/.MainActivity
+sleep 5
+```
+
+The app must be started AFTER `debug.rhea3.startWhenAppLaunch` is set, otherwise the trace server won't initialize. The 5s sleep after launch gives the btrace HTTP server time to start.
+
+### 4b: Play a sound to signal the user, then capture
+
+Play a sound when tracing actually starts so the user knows to begin interacting. Pipe btrace output through a loop that triggers the sound on the "start tracing" line:
+
+```bash
+java -jar tools/btrace/rhea-trace-shell.jar \
+  -a io.sentry.samples.android \
+  -t ${duration} \
+  -waitTraceTimeout 60 \
+  -o tools/btrace/traces/${branch_name}.pb \
+  sched 2>&1 | while IFS= read -r line; do
+    echo "$line"
+    if [[ "$line" == *"start tracing"* ]]; then
+      afplay -v 1.5 /System/Library/Sounds/Ping.aiff &
+    fi
+  done
+```
+
+For release builds with finer sampling, add `-sampleInterval 333000`.
+
+Do NOT use the `-r` flag — it fails to resolve the launcher activity because LeakCanary registers a second one. Launch the app manually in step 4a instead.
+
+### 4c: Switch branches for comparison
+
+When capturing a second branch:
+
+1. Stash the btrace integration changes:
+   ```bash
+   git stash push -m "btrace integration" -- \
+     sentry-samples/sentry-samples-android/build.gradle.kts \
+     sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java \
+     sentry-samples/sentry-samples-android/proguard-rules.pro
+   ```
+2. Checkout the other branch
+3. Pop the stash: `git stash pop`
+4. Rebuild and install (same variant — debug or release — as the first branch)
+5. Repeat steps 4a and 4b with a different output filename
+6. Switch back to the original branch and restore files
+
+## Step 5: Open in Perfetto UI
+
+Generate a viewer HTML and serve it locally. Use the template at `assets/viewer-template.html` as a base — copy it to `tools/btrace/traces/viewer.html` and replace the placeholder values:
+
+- `TRACE_FILES`: array of `{file, title}` objects for each captured trace
+- `SQL_QUERY`: the SQL query to prefill
+
+The SQL query is passed via the URL hash parameter: `https://ui.perfetto.dev/#!/?query=...`
+
+The trace data is sent via the postMessage API (required for local files — URL deep-linking does not work with `file://`).
+
+Start a local HTTP server and open the viewer:
+
+```bash
+cd tools/btrace/traces && python3 -m http.server 8008 &
+open http://localhost:8008/viewer.html
+```
+
+### Default SQL Query
+
+If no custom query is provided, use:
+
+```sql
+SELECT
+  s.name AS slice_name,
+  s.dur / 1e6 AS dur_ms,
+  s.ts,
+  t.name AS track_name
+FROM slice s
+JOIN thread_track t ON s.track_id = t.id
+WHERE s.name GLOB '*SentryWindowCallback.dispatch*'
+ORDER BY s.ts
+```
+
+## Step 6: Query and Compare Traces
+
+After capturing both branches, use `trace_processor` to compute comparison stats locally.
+
+### Basic stats query
+
+For each trace file, run:
+
+```bash
+/tmp/trace_processor -Q "
+WITH events AS (
+  SELECT s.dur / 1e6 as dur_ms FROM slice s
+  WHERE s.name GLOB '*${METHOD_GLOB}*' AND s.dur > 0
+  ORDER BY s.dur
+)
+SELECT COUNT(*) as count,
+  ROUND(AVG(dur_ms), 4) as avg_ms,
+  ROUND((SELECT dur_ms FROM events LIMIT 1 OFFSET (SELECT COUNT(*)/2 FROM events)), 4) as median_ms,
+  ROUND(MIN(dur_ms), 4) as min_ms,
+  ROUND(MAX(dur_ms), 4) as max_ms
+FROM events
+" tools/btrace/traces/${trace_file}.pb
+```
+
+Replace `${METHOD_GLOB}` with the method pattern to compare (e.g. `SentryGestureDetector.onTouchEvent`, `SentryWindowCallback.dispatchTouchEvent`).
+
+### Finding child calls (debug builds)
+
+To find what happens inside a method (e.g. Handler calls, lock acquisitions):
+
+```bash
+/tmp/trace_processor -Q "
+WITH RECURSIVE descendants(id, depth) AS (
+  SELECT s.id, 0 FROM slice s WHERE s.name GLOB '*${PARENT_METHOD}*'
+  UNION ALL
+  SELECT s.id, d.depth + 1 FROM slice s JOIN descendants d ON s.parent_id = d.id WHERE d.depth < 10
+)
+SELECT s.name, COUNT(*) as count, ROUND(AVG(s.dur / 1e6), 3) as avg_ms
+FROM slice s JOIN descendants d ON s.id = d.id
+WHERE d.depth > 0
+GROUP BY s.name ORDER BY count DESC
+LIMIT 20
+" tools/btrace/traces/${trace_file}.pb
+```
+
+### Build the comparison table
+
+Run the stats query on both trace files, then present a markdown table:
+
+```
+| Metric | Branch A | Branch B | Delta |
+|--------|----------|----------|-------|
+| Count  | ...      | ...      |       |
+| Average| ...      | ...      | -X%   |
+| Median | ...      | ...      | -X%   |
+| Max    | ...      | ...      | -X%   |
+```
+
+Compute delta as `(branchA - branchB) / branchB * 100`. Negative means branch A is faster.
+
+### Sampling rate reference
+
+| Rate | Interval | `-sampleInterval` | Use case |
+|------|----------|-------------------|----------|
+| 1 kHz | 1ms | `1000000` (default) | Debug builds, general profiling |
+| 3 kHz | 333μs | `333000` | Release builds, finer granularity |
+| 10 kHz | 100μs | `100000` | Maximum detail, higher overhead |
+
+Higher sampling rates capture shorter method calls but add CPU overhead which can skew results. For most comparisons, the default 1kHz is sufficient.
+
+## Cleanup
+
+After tracing is complete, remind the user that the btrace integration changes to the sample app should NOT be committed. The `tools/btrace/` directory is gitignored.
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| `No compatible library found [shadowhook]` | Restrict `ndk.abiFilters` to arm64-v8a only |
+| `package com.bytedance.btrace does not exist` | Use `com.bytedance.rheatrace` (not `btrace`) |
+| `ResolverActivity does not exist` with `-r` flag | Don't use `-r`; launch the app manually before capturing |
+| `wait for trace ready timeout` on download | Set `debug.rhea3.startWhenAppLaunch=1` BEFORE launching the app, and use `-waitTraceTimeout 60` |
+| Empty jar file (0 bytes) | Download from Maven Central (`repo1.maven.org`), not `oss.sonatype.org` |
+| `FileNotFoundException` on sampling download | App was already running when properties were set; force-stop and relaunch |
+| `SocketException: Unexpected end of file` in release builds | R8 stripped btrace classes; add `-keep class com.bytedance.rheatrace.** { *; }` to proguard-rules.pro |
+| Stale port from previous session | Run `adb shell "rm -rf /storage/emulated/0/Android/data/io.sentry.samples.android/files/rhea-port"` before launching |
+| Most `onTouchEvent` durations are 0ms | Increase sampling rate with `-sampleInterval 333000` (3kHz) |
diff --git a/.claude/skills/btrace-perfetto/assets/viewer-template.html b/.claude/skills/btrace-perfetto/assets/viewer-template.html
new file mode 100644
index 00000000000..4c31a24c342
--- /dev/null
+++ b/.claude/skills/btrace-perfetto/assets/viewer-template.html
@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html>
+<head><title>btrace Trace Viewer</title></head>
+<body>
+  <h2>Perfetto Trace Viewer</h2>
+  <div id="buttons"><!-- BUTTONS_PLACEHOLDER --></div>
+  <p id="status"></p>
+  <script>
+    // Replace these values when copying the template
+    var TRACE_FILES = [/* TRACE_FILES_PLACEHOLDER */];
+    var SQL_QUERY = `SQL_QUERY_PLACEHOLDER`;
+
+    var container = document.getElementById('buttons');
+    TRACE_FILES.forEach(function(t) {
+      var btn = document.createElement('button');
+      btn.textContent = 'Open ' + t.title;
+      btn.style.marginRight = '8px';
+      btn.onclick = function() { openTrace(t.file, t.title); };
+      container.appendChild(btn);
+    });
+
+    function openTrace(file, title) {
+      var status = document.getElementById('status');
+      status.textContent = 'Opening Perfetto UI...';
+      var url = 'https://ui.perfetto.dev/#!/?query=' + encodeURIComponent(SQL_QUERY);
+      var w = window.open(url);
+      var ping = setInterval(function() { w.postMessage('PING', '*'); }, 100);
+      window.onmessage = function(e) {
+        if (e.data === 'PONG') {
+          clearInterval(ping);
+          status.textContent = 'Loading trace: ' + file;
+          fetch(file)
+            .then(function(r) { return r.arrayBuffer(); })
+            .then(function(buf) {
+              w.postMessage({
+                perfetto: {
+                  buffer: buf,
+                  title: title,
+                  fileName: file
+                }
+              }, '*');
+              status.textContent = 'Trace sent to Perfetto UI!';
+            });
+        }
+      };
+    }
+  </script>
+</body>
+</html>
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8357f0699df..74219c17d9d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+
+- Fix ANR caused by `GestureDetectorCompat` Handler/MessageQueue lock contention in `SentryWindowCallback` ([#5138](https://github.com/getsentry/sentry-java/pull/5138))
+
 ### Internal
 
 - Bump AGP version from v8.6.0 to v8.13.1 ([#5063](https://github.com/getsentry/sentry-java/pull/5063))
diff --git a/agents.toml b/agents.toml
index b2347f8e7e6..b4c9e091b70 100644
--- a/agents.toml
+++ b/agents.toml
@@ -31,3 +31,7 @@ source = "path:.agents/skills/create-java-pr"
 [[skills]]
 name = "test"
 source = "path:.agents/skills/test"
+
+[[skills]]
+name = "btrace-perfetto"
+source = "path:.agents/skills/btrace-perfetto"
diff --git a/sentry-android-core/proguard-rules.pro b/sentry-android-core/proguard-rules.pro
index aca674442bf..4cd76f9a20d 100644
--- a/sentry-android-core/proguard-rules.pro
+++ b/sentry-android-core/proguard-rules.pro
@@ -1,7 +1,6 @@
 ##---------------Begin: proguard configuration for android-core  ----------
 
 ##---------------Begin: proguard configuration for androidx.core  ----------
--keep class androidx.core.view.GestureDetectorCompat { <init>(...); }
 -keep class androidx.core.app.FrameMetricsAggregator { <init>(...); }
 -keep interface androidx.core.view.ScrollingView { *; }
 ##---------------End: proguard configuration for androidx.core  ----------
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/UserInteractionIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/UserInteractionIntegration.java
index 9f47fc8666c..c0dd3f9eb71 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/UserInteractionIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/UserInteractionIntegration.java
@@ -28,14 +28,11 @@ public final class UserInteractionIntegration
   private @Nullable IScopes scopes;
   private @Nullable SentryAndroidOptions options;
 
-  private final boolean isAndroidXAvailable;
   private final boolean isAndroidxLifecycleAvailable;
 
   public UserInteractionIntegration(
       final @NotNull Application application, final @NotNull io.sentry.util.LoadClass classLoader) {
     this.application = Objects.requireNonNull(application, "Application is required");
-    isAndroidXAvailable =
-        classLoader.isClassAvailable("androidx.core.view.GestureDetectorCompat", options);
     isAndroidxLifecycleAvailable =
         classLoader.isClassAvailable("androidx.lifecycle.Lifecycle", options);
   }
@@ -128,27 +125,19 @@ public void register(@NotNull IScopes scopes, @NotNull SentryOptions options) {
         .log(SentryLevel.DEBUG, "UserInteractionIntegration enabled: %s", integrationEnabled);
 
     if (integrationEnabled) {
-      if (isAndroidXAvailable) {
-        application.registerActivityLifecycleCallbacks(this);
-        this.options.getLogger().log(SentryLevel.DEBUG, "UserInteractionIntegration installed.");
-        addIntegrationToSdkVersion("UserInteraction");
-
-        // In case of a deferred init, we hook into any resumed activity
-        if (isAndroidxLifecycleAvailable) {
-          final @Nullable Activity activity = CurrentActivityHolder.getInstance().getActivity();
-          if (activity instanceof LifecycleOwner) {
-            if (((LifecycleOwner) activity).getLifecycle().getCurrentState()
-                == Lifecycle.State.RESUMED) {
-              startTracking(activity);
-            }
+      application.registerActivityLifecycleCallbacks(this);
+      this.options.getLogger().log(SentryLevel.DEBUG, "UserInteractionIntegration installed.");
+      addIntegrationToSdkVersion("UserInteraction");
+
+      // In case of a deferred init, we hook into any resumed activity
+      if (isAndroidxLifecycleAvailable) {
+        final @Nullable Activity activity = CurrentActivityHolder.getInstance().getActivity();
+        if (activity instanceof LifecycleOwner) {
+          if (((LifecycleOwner) activity).getLifecycle().getCurrentState()
+              == Lifecycle.State.RESUMED) {
+            startTracking(activity);
           }
         }
-      } else {
-        options
-            .getLogger()
-            .log(
-                SentryLevel.INFO,
-                "androidx.core is not available, UserInteractionIntegration won't be installed");
       }
     }
   }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureDetector.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureDetector.java
new file mode 100644
index 00000000000..3196ae0189e
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureDetector.java
@@ -0,0 +1,147 @@
+package io.sentry.android.core.internal.gestures;
+
+import android.content.Context;
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.ViewConfiguration;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * A lightweight gesture detector that replaces {@code GestureDetectorCompat}/{@link
+ * GestureDetector} to avoid ANRs caused by Handler/MessageQueue lock contention and IPC calls
+ * (FrameworkStatsLog.write).
+ *
+ * <p>Only detects click (tap), scroll, and fling — the gestures used by {@link
+ * SentryGestureListener}. Long-press, show-press, and double-tap detection (which require Handler
+ * message scheduling) are intentionally omitted.
+ */
+@ApiStatus.Internal
+public final class SentryGestureDetector {
+
+  private final @NotNull GestureDetector.OnGestureListener listener;
+  private final int touchSlopSquare;
+  private final int minimumFlingVelocity;
+  private final int maximumFlingVelocity;
+
+  private boolean isInTapRegion;
+  private boolean ignoreUpEvent;
+  private float downX;
+  private float downY;
+  private float lastX;
+  private float lastY;
+  private @Nullable MotionEvent currentDownEvent;
+  private @Nullable VelocityTracker velocityTracker;
+
+  SentryGestureDetector(
+      final @NotNull Context context, final @NotNull GestureDetector.OnGestureListener listener) {
+    this.listener = listener;
+    final ViewConfiguration config = ViewConfiguration.get(context);
+    final int touchSlop = config.getScaledTouchSlop();
+    this.touchSlopSquare = touchSlop * touchSlop;
+    this.minimumFlingVelocity = config.getScaledMinimumFlingVelocity();
+    this.maximumFlingVelocity = config.getScaledMaximumFlingVelocity();
+  }
+
+  void onTouchEvent(final @NotNull MotionEvent event) {
+    final int action = event.getActionMasked();
+
+    if (velocityTracker == null) {
+      velocityTracker = VelocityTracker.obtain();
+    }
+
+    if (action == MotionEvent.ACTION_DOWN) {
+      velocityTracker.clear();
+    }
+    velocityTracker.addMovement(event);
+
+    switch (action) {
+      case MotionEvent.ACTION_DOWN:
+        downX = event.getX();
+        downY = event.getY();
+        lastX = downX;
+        lastY = downY;
+        isInTapRegion = true;
+        ignoreUpEvent = false;
+
+        if (currentDownEvent != null) {
+          currentDownEvent.recycle();
+        }
+        currentDownEvent = MotionEvent.obtain(event);
+
+        listener.onDown(event);
+        break;
+
+      case MotionEvent.ACTION_MOVE:
+        {
+          final float x = event.getX();
+          final float y = event.getY();
+          final float dx = x - downX;
+          final float dy = y - downY;
+          final float distanceSquare = (dx * dx) + (dy * dy);
+
+          if (distanceSquare > touchSlopSquare) {
+            final float scrollX = lastX - x;
+            final float scrollY = lastY - y;
+            listener.onScroll(currentDownEvent, event, scrollX, scrollY);
+            isInTapRegion = false;
+            lastX = x;
+            lastY = y;
+          }
+          break;
+        }
+
+      case MotionEvent.ACTION_POINTER_DOWN:
+        // A second finger means this is not a single tap (e.g. pinch-to-zoom).
+        // Also suppress the UP handler to avoid spurious fling detection when the
+        // last finger lifts quickly after a pinch — mirrors GestureDetector's
+        // mIgnoreNextUpEvent / cancelTaps() behavior.
+        isInTapRegion = false;
+        ignoreUpEvent = true;
+        break;
+
+      case MotionEvent.ACTION_UP:
+        if (ignoreUpEvent) {
+          endGesture();
+          break;
+        }
+        if (isInTapRegion) {
+          listener.onSingleTapUp(event);
+        } else {
+          final int pointerId = event.getPointerId(0);
+          velocityTracker.computeCurrentVelocity(1000, maximumFlingVelocity);
+          final float velocityX = velocityTracker.getXVelocity(pointerId);
+          final float velocityY = velocityTracker.getYVelocity(pointerId);
+
+          if (Math.abs(velocityX) > minimumFlingVelocity
+              || Math.abs(velocityY) > minimumFlingVelocity) {
+            listener.onFling(currentDownEvent, event, velocityX, velocityY);
+          }
+        }
+        endGesture();
+        break;
+
+      case MotionEvent.ACTION_CANCEL:
+        endGesture();
+        break;
+    }
+  }
+
+  /** Releases native resources. Call when the detector is no longer needed. */
+  void release() {
+    endGesture();
+    if (velocityTracker != null) {
+      velocityTracker.recycle();
+      velocityTracker = null;
+    }
+  }
+
+  private void endGesture() {
+    if (currentDownEvent != null) {
+      currentDownEvent.recycle();
+      currentDownEvent = null;
+    }
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
index edb9c9f9daa..557cd4e7a29 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
@@ -1,11 +1,8 @@
 package io.sentry.android.core.internal.gestures;
 
 import android.content.Context;
-import android.os.Handler;
-import android.os.Looper;
 import android.view.MotionEvent;
 import android.view.Window;
-import androidx.core.view.GestureDetectorCompat;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
 import io.sentry.SpanStatus;
@@ -18,7 +15,7 @@ public final class SentryWindowCallback extends WindowCallbackAdapter {
 
   private final @NotNull Window.Callback delegate;
   private final @NotNull SentryGestureListener gestureListener;
-  private final @NotNull GestureDetectorCompat gestureDetector;
+  private final @NotNull SentryGestureDetector gestureDetector;
   private final @Nullable SentryOptions options;
   private final @NotNull MotionEventObtainer motionEventObtainer;
 
@@ -29,7 +26,7 @@ public SentryWindowCallback(
       final @Nullable SentryOptions options) {
     this(
         delegate,
-        new GestureDetectorCompat(context, gestureListener, new Handler(Looper.getMainLooper())),
+        new SentryGestureDetector(context, gestureListener),
         gestureListener,
         options,
         new MotionEventObtainer() {});
@@ -37,7 +34,7 @@ public SentryWindowCallback(
 
   SentryWindowCallback(
       final @NotNull Window.Callback delegate,
-      final @NotNull GestureDetectorCompat gestureDetector,
+      final @NotNull SentryGestureDetector gestureDetector,
       final @NotNull SentryGestureListener gestureListener,
       final @Nullable SentryOptions options,
       final @NotNull MotionEventObtainer motionEventObtainer) {
@@ -76,6 +73,7 @@ private void handleTouchEvent(final @NotNull MotionEvent motionEvent) {
 
   public void stopTracking() {
     gestureListener.stopTracing(SpanStatus.CANCELLED);
+    gestureDetector.release();
   }
 
   public @NotNull Window.Callback getDelegate() {
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/UserInteractionIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/UserInteractionIntegrationTest.kt
index 4f1495a9875..f558841e6f5 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/UserInteractionIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/UserInteractionIntegrationTest.kt
@@ -39,16 +39,8 @@ class UserInteractionIntegrationTest {
 
     fun getSut(
       callback: Window.Callback? = null,
-      isAndroidXAvailable: Boolean = true,
       isLifecycleAvailable: Boolean = true,
     ): UserInteractionIntegration {
-      whenever(
-          loadClass.isClassAvailable(
-            eq("androidx.core.view.GestureDetectorCompat"),
-            anyOrNull<SentryAndroidOptions>(),
-          )
-        )
-        .thenReturn(isAndroidXAvailable)
       whenever(
           loadClass.isClassAvailable(
             eq("androidx.lifecycle.Lifecycle"),
@@ -99,15 +91,6 @@ class UserInteractionIntegrationTest {
     verify(fixture.application).unregisterActivityLifecycleCallbacks(any())
   }
 
-  @Test
-  fun `when androidx is unavailable doesn't register a callback`() {
-    val sut = fixture.getSut(isAndroidXAvailable = false)
-
-    sut.register(fixture.scopes, fixture.options)
-
-    verify(fixture.application, never()).registerActivityLifecycleCallbacks(any())
-  }
-
   @Test
   fun `registers window callback on activity resumed`() {
     val sut = fixture.getSut()
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureDetectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureDetectorTest.kt
new file mode 100644
index 00000000000..be15f9c578b
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureDetectorTest.kt
@@ -0,0 +1,386 @@
+package io.sentry.android.core.internal.gestures
+
+import android.os.SystemClock
+import android.view.GestureDetector
+import android.view.MotionEvent
+import android.view.ViewConfiguration
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import kotlin.test.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+
+@RunWith(AndroidJUnit4::class)
+class SentryGestureDetectorTest {
+
+  class Fixture {
+    val listener = mock<GestureDetector.OnGestureListener>()
+    val context = ApplicationProvider.getApplicationContext<android.content.Context>()
+    val touchSlop = ViewConfiguration.get(context).scaledTouchSlop
+
+    fun getSut(): SentryGestureDetector {
+      return SentryGestureDetector(context, listener)
+    }
+  }
+
+  private val fixture = Fixture()
+
+  @Test
+  fun `tap - DOWN followed by UP within touch slop fires onSingleTapUp`() {
+    val sut = fixture.getSut()
+    val downTime = SystemClock.uptimeMillis()
+
+    val down = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    val up = MotionEvent.obtain(downTime, downTime + 50, MotionEvent.ACTION_UP, 100f, 100f, 0)
+
+    sut.onTouchEvent(down)
+    sut.onTouchEvent(up)
+
+    verify(fixture.listener).onDown(down)
+    verify(fixture.listener).onSingleTapUp(up)
+    verify(fixture.listener, never()).onScroll(any(), any(), any(), any())
+    verify(fixture.listener, never()).onFling(anyOrNull(), any(), any(), any())
+
+    down.recycle()
+    up.recycle()
+  }
+
+  @Test
+  fun `no tap - DOWN followed by MOVE beyond slop and UP does not fire onSingleTapUp`() {
+    val sut = fixture.getSut()
+    val downTime = SystemClock.uptimeMillis()
+    val beyondSlop = fixture.touchSlop + 10f
+
+    val down = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    val move =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 16,
+        MotionEvent.ACTION_MOVE,
+        100f + beyondSlop,
+        100f,
+        0,
+      )
+    val up =
+      MotionEvent.obtain(downTime, downTime + 50, MotionEvent.ACTION_UP, 100f + beyondSlop, 100f, 0)
+
+    sut.onTouchEvent(down)
+    sut.onTouchEvent(move)
+    sut.onTouchEvent(up)
+
+    verify(fixture.listener, never()).onSingleTapUp(any())
+
+    down.recycle()
+    move.recycle()
+    up.recycle()
+  }
+
+  @Test
+  fun `scroll - DOWN followed by MOVE beyond slop fires onScroll with correct deltas`() {
+    val sut = fixture.getSut()
+    val downTime = SystemClock.uptimeMillis()
+    val beyondSlop = fixture.touchSlop + 10f
+
+    val down = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 200f, 0)
+    val move =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 16,
+        MotionEvent.ACTION_MOVE,
+        100f + beyondSlop,
+        200f,
+        0,
+      )
+
+    sut.onTouchEvent(down)
+    sut.onTouchEvent(move)
+
+    // scrollX = lastX - currentX = 100 - (100 + beyondSlop) = -beyondSlop
+    verify(fixture.listener).onScroll(anyOrNull(), eq(move), eq(-beyondSlop), eq(0f))
+
+    down.recycle()
+    move.recycle()
+  }
+
+  @Test
+  fun `fling - fast swipe fires onFling`() {
+    val sut = fixture.getSut()
+    val downTime = SystemClock.uptimeMillis()
+    val beyondSlop = fixture.touchSlop + 10f
+
+    val down = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    // Move far and fast (large distance in short time = high velocity)
+    val move =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 10,
+        MotionEvent.ACTION_MOVE,
+        100f + beyondSlop,
+        100f,
+        0,
+      )
+    val up = MotionEvent.obtain(downTime, downTime + 20, MotionEvent.ACTION_UP, 500f, 100f, 0)
+
+    sut.onTouchEvent(down)
+    sut.onTouchEvent(move)
+    sut.onTouchEvent(up)
+
+    verify(fixture.listener).onFling(anyOrNull(), eq(up), any(), any())
+
+    down.recycle()
+    move.recycle()
+    up.recycle()
+  }
+
+  @Test
+  fun `slow release - DOWN MOVE and slow UP does not fire onFling`() {
+    val sut = fixture.getSut()
+    val downTime = SystemClock.uptimeMillis()
+    val beyondSlop = fixture.touchSlop + 1f
+
+    val down = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    // Move just beyond slop
+    val move =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 100,
+        MotionEvent.ACTION_MOVE,
+        100f + beyondSlop,
+        100f,
+        0,
+      )
+    // Stay at the same position for a long time to ensure near-zero velocity
+    val moveStill =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 10000,
+        MotionEvent.ACTION_MOVE,
+        100f + beyondSlop,
+        100f,
+        0,
+      )
+    val up =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 10001,
+        MotionEvent.ACTION_UP,
+        100f + beyondSlop,
+        100f,
+        0,
+      )
+
+    sut.onTouchEvent(down)
+    sut.onTouchEvent(move)
+    sut.onTouchEvent(moveStill)
+    sut.onTouchEvent(up)
+
+    verify(fixture.listener, never()).onFling(anyOrNull(), any(), any(), any())
+
+    down.recycle()
+    move.recycle()
+    moveStill.recycle()
+    up.recycle()
+  }
+
+  @Test
+  fun `cancel - DOWN followed by CANCEL does not fire tap or fling callbacks`() {
+    val sut = fixture.getSut()
+    val downTime = SystemClock.uptimeMillis()
+
+    val down = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    val cancel =
+      MotionEvent.obtain(downTime, downTime + 50, MotionEvent.ACTION_CANCEL, 100f, 100f, 0)
+
+    sut.onTouchEvent(down)
+    sut.onTouchEvent(cancel)
+
+    verify(fixture.listener).onDown(down)
+    verify(fixture.listener, never()).onSingleTapUp(any())
+    verify(fixture.listener, never()).onScroll(any(), any(), any(), any())
+    verify(fixture.listener, never()).onFling(anyOrNull(), any(), any(), any())
+
+    down.recycle()
+    cancel.recycle()
+  }
+
+  @Test
+  fun `multi-touch - POINTER_DOWN cancels tap so UP does not fire onSingleTapUp`() {
+    val sut = fixture.getSut()
+    val downTime = SystemClock.uptimeMillis()
+
+    val down = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    // Second finger touches — encoded as ACTION_POINTER_DOWN with pointer index 1
+    val pointerDown =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 20,
+        (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT) or MotionEvent.ACTION_POINTER_DOWN,
+        100f,
+        100f,
+        0,
+      )
+    val up = MotionEvent.obtain(downTime, downTime + 100, MotionEvent.ACTION_UP, 100f, 100f, 0)
+
+    sut.onTouchEvent(down)
+    sut.onTouchEvent(pointerDown)
+    sut.onTouchEvent(up)
+
+    verify(fixture.listener).onDown(down)
+    verify(fixture.listener, never()).onSingleTapUp(any())
+
+    down.recycle()
+    pointerDown.recycle()
+    up.recycle()
+  }
+
+  @Test
+  fun `multi-touch - POINTER_DOWN suppresses fling on fast UP`() {
+    val sut = fixture.getSut()
+    val downTime = SystemClock.uptimeMillis()
+
+    val down = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    // Second finger touches
+    val pointerDown =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 20,
+        (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT) or MotionEvent.ACTION_POINTER_DOWN,
+        100f,
+        100f,
+        0,
+      )
+    // Second finger lifts
+    val pointerUp =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 40,
+        (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT) or MotionEvent.ACTION_POINTER_UP,
+        100f,
+        100f,
+        0,
+      )
+    // Last finger lifts quickly and far — would normally trigger fling
+    val up = MotionEvent.obtain(downTime, downTime + 50, MotionEvent.ACTION_UP, 500f, 100f, 0)
+
+    sut.onTouchEvent(down)
+    sut.onTouchEvent(pointerDown)
+    sut.onTouchEvent(pointerUp)
+    sut.onTouchEvent(up)
+
+    verify(fixture.listener, never()).onSingleTapUp(any())
+    verify(fixture.listener, never()).onFling(anyOrNull(), any(), any(), any())
+
+    down.recycle()
+    pointerDown.recycle()
+    pointerUp.recycle()
+    up.recycle()
+  }
+
+  @Test
+  fun `multi-touch - tap works again after multi-touch gesture ends`() {
+    val sut = fixture.getSut()
+    var downTime = SystemClock.uptimeMillis()
+
+    // First gesture: multi-touch (suppressed)
+    val down1 = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    val pointerDown =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 20,
+        (1 shl MotionEvent.ACTION_POINTER_INDEX_SHIFT) or MotionEvent.ACTION_POINTER_DOWN,
+        100f,
+        100f,
+        0,
+      )
+    val up1 = MotionEvent.obtain(downTime, downTime + 100, MotionEvent.ACTION_UP, 100f, 100f, 0)
+
+    sut.onTouchEvent(down1)
+    sut.onTouchEvent(pointerDown)
+    sut.onTouchEvent(up1)
+
+    verify(fixture.listener, never()).onSingleTapUp(any())
+
+    // Second gesture: normal tap — ignoreUpEvent should have been reset
+    downTime = SystemClock.uptimeMillis()
+    val down2 = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 200f, 200f, 0)
+    val up2 = MotionEvent.obtain(downTime, downTime + 50, MotionEvent.ACTION_UP, 200f, 200f, 0)
+
+    sut.onTouchEvent(down2)
+    sut.onTouchEvent(up2)
+
+    verify(fixture.listener).onSingleTapUp(up2)
+
+    down1.recycle()
+    pointerDown.recycle()
+    up1.recycle()
+    down2.recycle()
+    up2.recycle()
+  }
+
+  @Test
+  fun `sequential gestures - state resets between tap and scroll`() {
+    val sut = fixture.getSut()
+    val beyondSlop = fixture.touchSlop + 10f
+
+    // First gesture: tap
+    var downTime = SystemClock.uptimeMillis()
+    val down1 = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    val up1 = MotionEvent.obtain(downTime, downTime + 50, MotionEvent.ACTION_UP, 100f, 100f, 0)
+
+    sut.onTouchEvent(down1)
+    sut.onTouchEvent(up1)
+    verify(fixture.listener).onSingleTapUp(up1)
+
+    // Second gesture: scroll
+    downTime = SystemClock.uptimeMillis()
+    val down2 = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 200f, 200f, 0)
+    val move2 =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 16,
+        MotionEvent.ACTION_MOVE,
+        200f + beyondSlop,
+        200f,
+        0,
+      )
+    val up2 =
+      MotionEvent.obtain(
+        downTime,
+        downTime + 5000,
+        MotionEvent.ACTION_UP,
+        200f + beyondSlop,
+        200f,
+        0,
+      )
+
+    sut.onTouchEvent(down2)
+    sut.onTouchEvent(move2)
+    sut.onTouchEvent(up2)
+
+    verify(fixture.listener).onScroll(anyOrNull(), eq(move2), any(), any())
+    // onSingleTapUp should NOT have been called again for the second gesture
+    verify(fixture.listener, never()).onSingleTapUp(up2)
+
+    // Third gesture: another tap to verify clean reset
+    downTime = SystemClock.uptimeMillis()
+    val down3 = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 300f, 300f, 0)
+    val up3 = MotionEvent.obtain(downTime, downTime + 50, MotionEvent.ACTION_UP, 300f, 300f, 0)
+
+    sut.onTouchEvent(down3)
+    sut.onTouchEvent(up3)
+    verify(fixture.listener).onSingleTapUp(up3)
+
+    down1.recycle()
+    up1.recycle()
+    down2.recycle()
+    move2.recycle()
+    up2.recycle()
+    down3.recycle()
+    up3.recycle()
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryWindowCallbackTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryWindowCallbackTest.kt
index 856e6d0f156..8afc1b39304 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryWindowCallbackTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryWindowCallbackTest.kt
@@ -2,7 +2,6 @@ package io.sentry.android.core.internal.gestures
 
 import android.view.MotionEvent
 import android.view.Window
-import androidx.core.view.GestureDetectorCompat
 import io.sentry.android.core.SentryAndroidOptions
 import io.sentry.android.core.internal.gestures.SentryWindowCallback.MotionEventObtainer
 import kotlin.test.Test
@@ -18,7 +17,7 @@ class SentryWindowCallbackTest {
   class Fixture {
     val delegate = mock<Window.Callback>()
     val options = SentryAndroidOptions().apply { dsn = "https://key@sentry.io/proj" }
-    val gestureDetector = mock<GestureDetectorCompat>()
+    val gestureDetector = mock<SentryGestureDetector>()
     val gestureListener = mock<SentryGestureListener>()
     val motionEventCopy = mock<MotionEvent>()
 

From 12c8c2ace0ccd97d3efe1662e9cf8604441e1faf Mon Sep 17 00:00:00 2001
From: markushi <1411808+markushi@users.noreply.github.com>
Date: Thu, 16 Apr 2026 12:56:27 +0000
Subject: [PATCH 102/391] release: 8.39.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 74219c17d9d..6a2e72c1236 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.39.0
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index d9d50f79f73..5266e49135d 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.38.0
+versionName=8.39.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From bfc5ee11c3861539e7ecf5d5a49dc91c80fc8781 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Fri, 17 Apr 2026 05:49:17 +0200
Subject: [PATCH 103/391] fix(sentry): Recover object readers after
 deserialization errors (#5293)

* fix(sentry): Prevent object readers from hanging on bad values

Recover from deserializer failures by advancing past the broken value
instead of retrying the same token forever. This keeps list and map
helpers progressing and preserves later valid entries.

Track nesting in JsonObjectReader so recovery also works after a
partially consumed object or array. Implement skipValue in
MapObjectReader and avoid consuming stack entries before type checks
so failed reads do not corrupt the remaining input.

Fixes GH-5278
Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sentry): Guard JsonObjectReader recovery failures

Abort collection recovery gracefully when the stream is already
unrecoverable instead of letting recoverValue fail from inside the
original error handler.

Log an explicit error and stop iterating so malformed or truncated JSON
does not leave the reader in a worse state while still allowing the
container to close cleanly.

Refs GH-5278
Co-Authored-By: Claude <noreply@anthropic.com>

* ref(sentry): Extract JsonObjectReader recovery helper

Move the repeated recovery logging flow behind a dedicated helper
so the collection readers stay focused on parsing and keep the guarded
recovery behavior aligned across all three paths.

This does not change behavior. It only removes duplicated error
handling around failed value recovery.

Refs GH-5278
Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sentry): Unwind MapObjectReader failures fully

Recover MapObjectReader values back to their stack checkpoint so
partially consumed nested objects do not leave child entries or end
sentinels behind.

This keeps later values readable after a deserializer fails mid-object
and adds regression coverage for list, map, and map-of-lists paths that
partially enter nested values before throwing.

Refs GH-5278
Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* fix(sentry): Track container entry during JSON recovery

Track recovery state per collection element so post-parse validation
failures do not cause the next sibling container to be skipped.
This keeps the livelock fix while preserving later valid values after
a failed object deserializer.

Refs GH-5278
Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sentry): Track consumed values during JSON recovery

Treat recovery state as consumed when the current value has already
been read, including skipValue()-driven failures. This prevents the
fallback recovery step from skipping the next valid sibling after a
deserializer consumes a value and then throws.

Add regressions for direct list recovery and nested map-of-list
recovery so consumed-value failures keep later valid entries.

Refs GH-5278
Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sentry): Log unknown key recovery failures

Log a second error when unknown-field recovery itself fails.
This makes nextUnknown consistent with the list and map recovery
paths and makes truncated payload failures easier to diagnose.

Add regression coverage for unknown-key deserialization failures
that also leave the stream unrecoverable.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs(changelog): Clarify JSON recovery log levels

Clarify that collection recovery emits warning logs for skipped
values, while unknown-key failures and unrecoverable recovery
paths emit errors.

This keeps the release note aligned with the actual logging
behavior from the recovery fixes.

Co-Authored-By: Claude <noreply@anthropic.com>

* merge changelog lines

* mark consumed afterwards instead of before

* test(sentry): Remove explicit timeouts from reader recovery tests

Remove the explicit JUnit timeout annotations from the new JsonObjectReader and MapObjectReader recovery tests.

These tests already fail deterministically and do not need per-test timeouts. Dropping the annotations keeps the new coverage aligned with the rest of the suite and avoids extra noise in the test definitions.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(sentry): Rename mismatched MapObjectReader recovery tests

Rename the partially consumed MapObjectReader recovery tests so their names match the map iteration order.

MapObjectReader reads map entries in reverse insertion order from its stack. The previous names described the surviving values as coming after the failure even though they are read before it.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sentry): Mark skipped values consumed after success

Move skipValue consumption tracking after the underlying Gson skip succeeds.

This keeps valueConsumed aligned with the primitive reader methods and avoids marking a value as consumed before JsonReader has actually advanced past it.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sentry): Handle empty collections in MapObjectReader

Gate the recovery loops on the current token instead of hasNext when reading maps and lists.

MapObjectReader keeps END_OBJECT and END_ARRAY sentinels on its stack, so hasNext stays true
for empty collections. Checking the token preserves empty map and empty list handling after
moving nextName outside the inner recovery try-catch, and the new tests cover those cases.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sentry): Preserve list recovery in MapObjectReader

Continue list recovery until the END_ARRAY sentinel instead of stopping at the next non-object token.

A failed object element could be followed by an invalid primitive and then a valid object. The old
loop stopped at the primitive, letting endArray pop the wrong stack entry and leaving the reader in
an inconsistent state. The updated loop keeps recovering until the array is fully consumed, and the
new tests cover empty collections and mixed invalid list contents.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(sentry): Continue list recovery until array end

Continue JsonObjectReader list deserialization until the array boundary
instead of stopping when the next token is not BEGIN_OBJECT.

After recovering from a failed object element, the next unread token can be a
primitive. The previous loop exited early in that case and then aborted when
endArray() encountered unread content. Iterating with hasNext() keeps recovery
aligned with the actual array boundary.

Add a regression test covering a failing object followed by a primitive and a
later valid object.

Fixes GH-5278
Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   4 +
 .../main/java/io/sentry/JsonObjectReader.java | 218 ++++++++---
 .../java/io/sentry/util/MapObjectReader.java  |  56 ++-
 .../java/io/sentry/JsonObjectReaderTest.kt    | 337 ++++++++++++++++++
 .../io/sentry/util/MapObjectReaderTest.kt     | 207 ++++++++++-
 5 files changed, 763 insertions(+), 59 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6a2e72c1236..7e26f52e5dd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@
 
 ### Fixes
 
+- Fix `JsonObjectReader` and `MapObjectReader` hanging indefinitely when deserialization errors leave the reader in an inconsistent state ([#5293](https://github.com/getsentry/sentry-java/pull/5293))
+  - Failed collection values are now skipped so parsing can continue
+  - Skipped collection values emit `WARNING` logs
+  - Unknown-key failures and unrecoverable recovery failures emit `ERROR` logs
 - Fix ANR caused by `GestureDetectorCompat` Handler/MessageQueue lock contention in `SentryWindowCallback` ([#5138](https://github.com/getsentry/sentry-java/pull/5138))
 
 ### Internal
diff --git a/sentry/src/main/java/io/sentry/JsonObjectReader.java b/sentry/src/main/java/io/sentry/JsonObjectReader.java
index f9fe1841847..fef9bfc71ff 100644
--- a/sentry/src/main/java/io/sentry/JsonObjectReader.java
+++ b/sentry/src/main/java/io/sentry/JsonObjectReader.java
@@ -4,8 +4,10 @@
 import io.sentry.vendor.gson.stream.JsonToken;
 import java.io.IOException;
 import java.io.Reader;
+import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Date;
+import java.util.Deque;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -18,6 +20,8 @@
 public final class JsonObjectReader implements ObjectReader {
 
   private final @NotNull JsonReader jsonReader;
+  private final @NotNull Deque<RecoveryState> recoveryStates = new ArrayDeque<>();
+  private int depth = 0;
 
   public JsonObjectReader(Reader in) {
     this.jsonReader = new JsonReader(in);
@@ -26,25 +30,25 @@ public JsonObjectReader(Reader in) {
   @Override
   public @Nullable String nextStringOrNull() throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
-    return jsonReader.nextString();
+    return nextString();
   }
 
   @Override
   public @Nullable Double nextDoubleOrNull() throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
-    return jsonReader.nextDouble();
+    return nextDouble();
   }
 
   @Override
   public @Nullable Float nextFloatOrNull() throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
     return nextFloat();
@@ -52,42 +56,58 @@ public JsonObjectReader(Reader in) {
 
   @Override
   public float nextFloat() throws IOException {
-    return (float) jsonReader.nextDouble();
+    final double value = jsonReader.nextDouble();
+    markValueConsumed();
+    return (float) value;
   }
 
   @Override
   public @Nullable Long nextLongOrNull() throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
-    return jsonReader.nextLong();
+    return nextLong();
   }
 
   @Override
   public @Nullable Integer nextIntegerOrNull() throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
-    return jsonReader.nextInt();
+    return nextInt();
   }
 
   @Override
   public @Nullable Boolean nextBooleanOrNull() throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
-    return jsonReader.nextBoolean();
+    return nextBoolean();
   }
 
   @Override
   public void nextUnknown(ILogger logger, Map<String, Object> unknown, String name) {
+    RecoveryState recoveryState = null;
     try {
+      recoveryState = beginRecovery(peek());
       unknown.put(name, nextObjectOrNull());
     } catch (Exception exception) {
       logger.log(SentryLevel.ERROR, exception, "Error deserializing unknown key: %s", name);
+      if (recoveryState != null) {
+        try {
+          recoverValue(recoveryState);
+        } catch (Exception recoveryException) {
+          logger.log(
+              SentryLevel.ERROR,
+              "Stream unrecoverable after unknown key deserialization failure.",
+              recoveryException);
+        }
+      }
+    } finally {
+      endRecovery(recoveryState);
     }
   }
 
@@ -95,21 +115,29 @@ public void nextUnknown(ILogger logger, Map<String, Object> unknown, String name
   public <T> @Nullable List<T> nextListOrNull(
       @NotNull ILogger logger, @NotNull JsonDeserializer<T> deserializer) throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
-    jsonReader.beginArray();
+    beginArray();
     List<T> list = new ArrayList<>();
-    if (jsonReader.hasNext()) {
-      do {
-        try {
-          list.add(deserializer.deserialize(this, logger));
-        } catch (Exception e) {
-          logger.log(SentryLevel.WARNING, "Failed to deserialize object in list.", e);
+    while (jsonReader.hasNext()) {
+      final RecoveryState recoveryState = beginRecovery(peek());
+      try {
+        list.add(deserializer.deserialize(this, logger));
+      } catch (Exception e) {
+        if (!recoverAfterValueFailure(
+            logger,
+            e,
+            "Failed to deserialize object in list.",
+            "Stream unrecoverable, aborting list deserialization.",
+            recoveryState)) {
+          break;
         }
-      } while (jsonReader.peek() == JsonToken.BEGIN_OBJECT);
+      } finally {
+        endRecovery(recoveryState);
+      }
     }
-    jsonReader.endArray();
+    endArray();
     return list;
   }
 
@@ -117,23 +145,33 @@ public void nextUnknown(ILogger logger, Map<String, Object> unknown, String name
   public <T> @Nullable Map<String, T> nextMapOrNull(
       @NotNull ILogger logger, @NotNull JsonDeserializer<T> deserializer) throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
-    jsonReader.beginObject();
+    beginObject();
     Map<String, T> map = new HashMap<>();
     if (jsonReader.hasNext()) {
       do {
+        final String key = jsonReader.nextName();
+        final RecoveryState recoveryState = beginRecovery(peek());
         try {
-          String key = jsonReader.nextName();
           map.put(key, deserializer.deserialize(this, logger));
         } catch (Exception e) {
-          logger.log(SentryLevel.WARNING, "Failed to deserialize object in map.", e);
+          if (!recoverAfterValueFailure(
+              logger,
+              e,
+              "Failed to deserialize object in map.",
+              "Stream unrecoverable, aborting map deserialization.",
+              recoveryState)) {
+            break;
+          }
+        } finally {
+          endRecovery(recoveryState);
         }
       } while (jsonReader.peek() == JsonToken.BEGIN_OBJECT || jsonReader.peek() == JsonToken.NAME);
     }
 
-    jsonReader.endObject();
+    endObject();
     return map;
   }
 
@@ -151,9 +189,23 @@ public void nextUnknown(ILogger logger, Map<String, Object> unknown, String name
     if (hasNext()) {
       do {
         final @NotNull String key = nextName();
-        final @Nullable List<T> list = nextListOrNull(logger, deserializer);
-        if (list != null) {
-          result.put(key, list);
+        final RecoveryState recoveryState = beginRecovery(peek());
+        try {
+          final @Nullable List<T> list = nextListOrNull(logger, deserializer);
+          if (list != null) {
+            result.put(key, list);
+          }
+        } catch (Exception e) {
+          if (!recoverAfterValueFailure(
+              logger,
+              e,
+              "Failed to deserialize list in map.",
+              "Stream unrecoverable, aborting map-of-lists deserialization.",
+              recoveryState)) {
+            break;
+          }
+        } finally {
+          endRecovery(recoveryState);
         }
       } while (peek() == JsonToken.BEGIN_OBJECT || peek() == JsonToken.NAME);
     }
@@ -166,7 +218,7 @@ public void nextUnknown(ILogger logger, Map<String, Object> unknown, String name
   public <T> @Nullable T nextOrNull(
       @NotNull ILogger logger, @NotNull JsonDeserializer<T> deserializer) throws Exception {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
     return deserializer.deserialize(this, logger);
@@ -175,20 +227,20 @@ public void nextUnknown(ILogger logger, Map<String, Object> unknown, String name
   @Override
   public @Nullable Date nextDateOrNull(ILogger logger) throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
-    return ObjectReader.dateOrNull(jsonReader.nextString(), logger);
+    return ObjectReader.dateOrNull(nextString(), logger);
   }
 
   @Override
   public @Nullable TimeZone nextTimeZoneOrNull(ILogger logger) throws IOException {
     if (jsonReader.peek() == JsonToken.NULL) {
-      jsonReader.nextNull();
+      nextNull();
       return null;
     }
     try {
-      return TimeZone.getTimeZone(jsonReader.nextString());
+      return TimeZone.getTimeZone(nextString());
     } catch (Exception e) {
       logger.log(SentryLevel.ERROR, "Error when deserializing TimeZone", e);
     }
@@ -219,21 +271,27 @@ public void nextUnknown(ILogger logger, Map<String, Object> unknown, String name
   @Override
   public void beginObject() throws IOException {
     jsonReader.beginObject();
+    markValueConsumed();
+    depth++;
   }
 
   @Override
   public void endObject() throws IOException {
     jsonReader.endObject();
+    depth--;
   }
 
   @Override
   public void beginArray() throws IOException {
     jsonReader.beginArray();
+    markValueConsumed();
+    depth++;
   }
 
   @Override
   public void endArray() throws IOException {
     jsonReader.endArray();
+    depth--;
   }
 
   @Override
@@ -243,32 +301,43 @@ public boolean hasNext() throws IOException {
 
   @Override
   public int nextInt() throws IOException {
-    return jsonReader.nextInt();
+    final int value = jsonReader.nextInt();
+    markValueConsumed();
+    return value;
   }
 
   @Override
   public long nextLong() throws IOException {
-    return jsonReader.nextLong();
+    final long value = jsonReader.nextLong();
+    markValueConsumed();
+    return value;
   }
 
   @Override
   public String nextString() throws IOException {
-    return jsonReader.nextString();
+    final String value = jsonReader.nextString();
+    markValueConsumed();
+    return value;
   }
 
   @Override
   public boolean nextBoolean() throws IOException {
-    return jsonReader.nextBoolean();
+    final boolean value = jsonReader.nextBoolean();
+    markValueConsumed();
+    return value;
   }
 
   @Override
   public double nextDouble() throws IOException {
-    return jsonReader.nextDouble();
+    final double value = jsonReader.nextDouble();
+    markValueConsumed();
+    return value;
   }
 
   @Override
   public void nextNull() throws IOException {
     jsonReader.nextNull();
+    markValueConsumed();
   }
 
   @Override
@@ -279,10 +348,79 @@ public void setLenient(boolean lenient) {
   @Override
   public void skipValue() throws IOException {
     jsonReader.skipValue();
+    markValueConsumed();
+  }
+
+  private boolean recoverAfterValueFailure(
+      final @NotNull ILogger logger,
+      final @NotNull Exception error,
+      final @NotNull String warningMessage,
+      final @NotNull String unrecoverableMessage,
+      final @NotNull RecoveryState recoveryState) {
+    logger.log(SentryLevel.WARNING, warningMessage, error);
+    try {
+      recoverValue(recoveryState);
+      return true;
+    } catch (Exception recoveryException) {
+      logger.log(SentryLevel.ERROR, unrecoverableMessage, recoveryException);
+      return false;
+    }
+  }
+
+  private @NotNull RecoveryState beginRecovery(final @NotNull JsonToken startToken) {
+    final RecoveryState recoveryState = new RecoveryState(depth, startToken);
+    recoveryStates.addLast(recoveryState);
+    return recoveryState;
+  }
+
+  private void endRecovery(final @Nullable RecoveryState recoveryState) {
+    if (recoveryState == null) {
+      return;
+    }
+    if (!recoveryStates.isEmpty() && recoveryStates.peekLast() == recoveryState) {
+      recoveryStates.removeLast();
+    } else {
+      recoveryStates.remove(recoveryState);
+    }
+  }
+
+  private void markValueConsumed() {
+    final @Nullable RecoveryState recoveryState = recoveryStates.peekLast();
+    if (recoveryState != null) {
+      recoveryState.valueConsumed = true;
+    }
+  }
+
+  private void recoverValue(final @NotNull RecoveryState recoveryState) throws IOException {
+    while (depth > recoveryState.startDepth) {
+      final JsonToken token = peek();
+      if (token == JsonToken.END_OBJECT) {
+        endObject();
+      } else if (token == JsonToken.END_ARRAY) {
+        endArray();
+      } else {
+        skipValue();
+      }
+    }
+
+    if (!recoveryState.valueConsumed && peek() == recoveryState.startToken) {
+      skipValue();
+    }
   }
 
   @Override
   public void close() throws IOException {
     jsonReader.close();
   }
+
+  private static final class RecoveryState {
+    private final int startDepth;
+    private final @NotNull JsonToken startToken;
+    private boolean valueConsumed;
+
+    private RecoveryState(final int startDepth, final @NotNull JsonToken startToken) {
+      this.startDepth = startDepth;
+      this.startToken = startToken;
+    }
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/util/MapObjectReader.java b/sentry/src/main/java/io/sentry/util/MapObjectReader.java
index b04fbb96751..edd91190c82 100644
--- a/sentry/src/main/java/io/sentry/util/MapObjectReader.java
+++ b/sentry/src/main/java/io/sentry/util/MapObjectReader.java
@@ -31,10 +31,12 @@ public MapObjectReader(final Map<String, Object> root) {
   @Override
   public void nextUnknown(
       final @NotNull ILogger logger, final Map<String, Object> unknown, final String name) {
+    final int stackSizeBefore = stack.size();
     try {
       unknown.put(name, nextObjectOrNull());
     } catch (Exception exception) {
       logger.log(SentryLevel.ERROR, exception, "Error deserializing unknown key: %s", name);
+      recoverValue(stackSizeBefore);
     }
   }
 
@@ -50,14 +52,14 @@ public <T> List<T> nextListOrNull(
     try {
       beginArray();
       List<T> list = new ArrayList<>();
-      if (hasNext()) {
-        do {
-          try {
-            list.add(deserializer.deserialize(this, logger));
-          } catch (Exception e) {
-            logger.log(SentryLevel.WARNING, "Failed to deserialize object in list.", e);
-          }
-        } while (peek() == JsonToken.BEGIN_OBJECT);
+      while (peek() != JsonToken.END_ARRAY) {
+        final int stackSizeBefore = stack.size();
+        try {
+          list.add(deserializer.deserialize(this, logger));
+        } catch (Exception e) {
+          logger.log(SentryLevel.WARNING, "Failed to deserialize object in list.", e);
+          recoverValue(stackSizeBefore);
+        }
       }
       endArray();
       return list;
@@ -78,13 +80,15 @@ public <T> Map<String, T> nextMapOrNull(
     try {
       beginObject();
       Map<String, T> map = new HashMap<>();
-      if (hasNext()) {
+      if (peek() == JsonToken.NAME) {
         do {
+          final String key = nextName();
+          final int stackSizeBefore = stack.size();
           try {
-            String key = nextName();
             map.put(key, deserializer.deserialize(this, logger));
           } catch (Exception e) {
             logger.log(SentryLevel.WARNING, "Failed to deserialize object in map.", e);
+            recoverValue(stackSizeBefore);
           }
         } while (peek() == JsonToken.BEGIN_OBJECT || peek() == JsonToken.NAME);
       }
@@ -106,12 +110,18 @@ public <T> Map<String, T> nextMapOrNull(
 
     try {
       beginObject();
-      if (hasNext()) {
+      if (peek() == JsonToken.NAME) {
         do {
           final @NotNull String key = nextName();
-          final @Nullable List<T> list = nextListOrNull(logger, deserializer);
-          if (list != null) {
-            result.put(key, list);
+          final int stackSizeBefore = stack.size();
+          try {
+            final @Nullable List<T> list = nextListOrNull(logger, deserializer);
+            if (list != null) {
+              result.put(key, list);
+            }
+          } catch (Exception e) {
+            logger.log(SentryLevel.WARNING, "Failed to deserialize list in map.", e);
+            recoverValue(stackSizeBefore);
           }
         } while (peek() == JsonToken.BEGIN_OBJECT || peek() == JsonToken.NAME);
       }
@@ -197,12 +207,13 @@ public String nextName() throws IOException {
 
   @Override
   public void beginObject() throws IOException {
-    final Map.Entry<String, Object> currentEntry = stack.removeLast();
+    final Map.Entry<String, Object> currentEntry = stack.peekLast();
     if (currentEntry == null) {
       throw new IOException("No more entries");
     }
     final Object value = currentEntry.getValue();
     if (value instanceof Map) {
+      stack.removeLast();
       // insert a dummy entry to indicate end of an object
       stack.addLast(new AbstractMap.SimpleEntry<>(null, JsonToken.END_OBJECT));
       // extract map entries onto the stack
@@ -223,12 +234,13 @@ public void endObject() throws IOException {
 
   @Override
   public void beginArray() throws IOException {
-    final Map.Entry<String, Object> currentEntry = stack.removeLast();
+    final Map.Entry<String, Object> currentEntry = stack.peekLast();
     if (currentEntry == null) {
       throw new IOException("No more entries");
     }
     final Object value = currentEntry.getValue();
     if (value instanceof List) {
+      stack.removeLast();
       // insert a dummy entry to indicate end of an object
       stack.addLast(new AbstractMap.SimpleEntry<>(null, JsonToken.END_ARRAY));
       // extract map entries onto the stack
@@ -377,7 +389,17 @@ public void nextNull() throws IOException {
   public void setLenient(final boolean lenient) {}
 
   @Override
-  public void skipValue() throws IOException {}
+  public void skipValue() throws IOException {
+    if (!stack.isEmpty()) {
+      stack.removeLast();
+    }
+  }
+
+  private void recoverValue(final int stackSizeBefore) {
+    while (!stack.isEmpty() && stack.size() >= stackSizeBefore) {
+      stack.removeLast();
+    }
+  }
 
   @SuppressWarnings("TypeParameterUnusedInFormals")
   @Nullable
diff --git a/sentry/src/test/java/io/sentry/JsonObjectReaderTest.kt b/sentry/src/test/java/io/sentry/JsonObjectReaderTest.kt
index 45c97122ee3..d4fd525a87b 100644
--- a/sentry/src/test/java/io/sentry/JsonObjectReaderTest.kt
+++ b/sentry/src/test/java/io/sentry/JsonObjectReaderTest.kt
@@ -2,12 +2,15 @@ package io.sentry
 
 import java.io.StringReader
 import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 import kotlin.test.assertNull
 import org.junit.Test
 import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.verifyNoMoreInteractions
 
 class JsonObjectReaderTest {
   class Fixture {
@@ -18,6 +21,49 @@ class JsonObjectReaderTest {
 
   val fixture = Fixture()
 
+  private val throwingValueDeserializer =
+    JsonDeserializer<String> { reader, _ ->
+      reader.beginObject()
+      reader.nextName()
+      val value = reader.nextString()
+      if (value == "fail") {
+        throw IllegalStateException("intentional")
+      }
+      reader.endObject()
+      value
+    }
+
+  private val postParseThrowingValueDeserializer =
+    JsonDeserializer<String> { reader, _ ->
+      reader.beginObject()
+      reader.nextName()
+      val value = reader.nextString()
+      reader.endObject()
+      if (value == "fail") {
+        throw IllegalStateException("intentional")
+      }
+      value
+    }
+
+  private fun getValuesReader(jsonValue: String): JsonObjectReader =
+    fixture.getSut("{\"values\": $jsonValue}").apply {
+      beginObject()
+      nextName()
+    }
+
+  private fun <T> assertNextMapOrNullRecoversAfterFailedPrimitiveRead(
+    badValue: String,
+    goodValue: String,
+    expectedValue: T,
+    deserializer: JsonDeserializer<T>,
+  ) {
+    val actual =
+      getValuesReader("{\"bad\": $badValue, \"good\": $goodValue}")
+        .nextMapOrNull(fixture.logger, deserializer)
+
+    assertEquals(mapOf("good" to expectedValue), actual)
+  }
+
   // nextStringOrNull
 
   @Test
@@ -198,6 +244,297 @@ class JsonObjectReaderTest {
     verify(fixture.logger, never()).log(any(), any(), any<Throwable>())
   }
 
+  @Test
+  fun `nextListOrNull skips a failing element`() {
+    val actual =
+      getValuesReader("[{\"value\": \"fail\"}]")
+        .nextListOrNull(fixture.logger, throwingValueDeserializer)
+
+    assertEquals(emptyList(), actual)
+  }
+
+  @Test
+  fun `nextListOrNull skips an unconsumed failing element`() {
+    var callCount = 0
+    val deserializer =
+      JsonDeserializer<String> { reader, logger ->
+        if (callCount++ == 0) {
+          throw IllegalStateException("intentional")
+        }
+        throwingValueDeserializer.deserialize(reader, logger)
+      }
+
+    val actual =
+      getValuesReader("[{\"value\": \"ignored\"}, {\"value\": \"two\"}]")
+        .nextListOrNull(fixture.logger, deserializer)
+
+    assertEquals(listOf("two"), actual)
+  }
+
+  @Test
+  fun `nextListOrNull keeps elements before a failing element`() {
+    val actual =
+      getValuesReader("[{\"value\": \"one\"}, {\"value\": \"fail\"}]")
+        .nextListOrNull(fixture.logger, throwingValueDeserializer)
+
+    assertEquals(listOf("one"), actual)
+  }
+
+  @Test
+  fun `nextListOrNull keeps elements after a failing element`() {
+    val actual =
+      getValuesReader("[{\"value\": \"fail\"}, {\"value\": \"two\"}]")
+        .nextListOrNull(fixture.logger, throwingValueDeserializer)
+
+    assertEquals(listOf("two"), actual)
+  }
+
+  @Test
+  fun `nextListOrNull keeps elements after a fully consumed failing element`() {
+    val actual =
+      getValuesReader("[{\"value\": \"fail\"}, {\"value\": \"two\"}]")
+        .nextListOrNull(fixture.logger, postParseThrowingValueDeserializer)
+
+    assertEquals(listOf("two"), actual)
+  }
+
+  @Test
+  fun `nextListOrNull keeps elements after a failing object followed by a primitive`() {
+    val reader =
+      getValuesReader(
+        "[{\"kind\": \"fail\", \"value\": \"bad\"}, \"oops\", {\"kind\": \"ok\", \"value\": \"two\"}]"
+      )
+    val deserializer =
+      JsonDeserializer<String> { objectReader, _ ->
+        objectReader.beginObject()
+        objectReader.nextName()
+        if (objectReader.nextString() == "fail") {
+          throw IllegalStateException("intentional")
+        }
+        objectReader.nextName()
+        val value = objectReader.nextString()
+        objectReader.endObject()
+        value
+      }
+
+    val actual = reader.nextListOrNull(fixture.logger, deserializer)
+
+    assertEquals(listOf("two"), actual)
+    assertEquals(io.sentry.vendor.gson.stream.JsonToken.END_OBJECT, reader.peek())
+  }
+
+  @Test
+  fun `nextListOrNull keeps elements after skipValue consumes a failing element`() {
+    var callCount = 0
+    val deserializer =
+      JsonDeserializer<String> { reader, logger ->
+        if (callCount++ == 0) {
+          reader.skipValue()
+          throw IllegalStateException("intentional")
+        }
+        throwingValueDeserializer.deserialize(reader, logger)
+      }
+
+    val actual =
+      getValuesReader("[{\"value\": \"ignored\"}, {\"value\": \"two\"}]")
+        .nextListOrNull(fixture.logger, deserializer)
+
+    assertEquals(listOf("two"), actual)
+  }
+
+  @Test
+  fun `nextMapOrNull skips a failing value`() {
+    val actual =
+      getValuesReader("{\"bad\": {\"value\": \"fail\"}}")
+        .nextMapOrNull(fixture.logger, throwingValueDeserializer)
+
+    assertEquals(emptyMap(), actual)
+  }
+
+  @Test
+  fun `nextMapOrNull recovers after failed primitive reads`() {
+    assertNextMapOrNullRecoversAfterFailedPrimitiveRead(
+      badValue = "true",
+      goodValue = "2",
+      expectedValue = 2,
+      deserializer = JsonDeserializer { reader, _ -> reader.nextInt() },
+    )
+    assertNextMapOrNullRecoversAfterFailedPrimitiveRead(
+      badValue = "true",
+      goodValue = "2",
+      expectedValue = 2L,
+      deserializer = JsonDeserializer { reader, _ -> reader.nextLong() },
+    )
+    assertNextMapOrNullRecoversAfterFailedPrimitiveRead(
+      badValue = "true",
+      goodValue = "\"two\"",
+      expectedValue = "two",
+      deserializer = JsonDeserializer { reader, _ -> reader.nextString() },
+    )
+    assertNextMapOrNullRecoversAfterFailedPrimitiveRead(
+      badValue = "1",
+      goodValue = "false",
+      expectedValue = false,
+      deserializer = JsonDeserializer { reader, _ -> reader.nextBoolean() },
+    )
+    assertNextMapOrNullRecoversAfterFailedPrimitiveRead(
+      badValue = "true",
+      goodValue = "2.5",
+      expectedValue = 2.5,
+      deserializer = JsonDeserializer { reader, _ -> reader.nextDouble() },
+    )
+    assertNextMapOrNullRecoversAfterFailedPrimitiveRead(
+      badValue = "true",
+      goodValue = "null",
+      expectedValue = Unit,
+      deserializer = JsonDeserializer { reader, _ -> reader.nextNull() },
+    )
+    assertNextMapOrNullRecoversAfterFailedPrimitiveRead(
+      badValue = "true",
+      goodValue = "2.5",
+      expectedValue = 2.5f,
+      deserializer = JsonDeserializer { reader, _ -> reader.nextFloat() },
+    )
+  }
+
+  @Test
+  fun `nextMapOrNull keeps values before a failing value`() {
+    val actual =
+      getValuesReader("{\"good\": {\"value\": \"one\"}, \"bad\": {\"value\": \"fail\"}}")
+        .nextMapOrNull(fixture.logger, throwingValueDeserializer)
+
+    assertEquals(mapOf("good" to "one"), actual)
+  }
+
+  @Test
+  fun `nextMapOrNull keeps values after a failing value`() {
+    val actual =
+      getValuesReader("{\"bad\": {\"value\": \"fail\"}, \"good\": {\"value\": \"two\"}}")
+        .nextMapOrNull(fixture.logger, throwingValueDeserializer)
+
+    assertEquals(mapOf("good" to "two"), actual)
+  }
+
+  @Test
+  fun `nextMapOfListOrNull skips a failing value`() {
+    val actual =
+      getValuesReader("{\"bad\": {\"value\": \"fail\"}}")
+        .nextMapOfListOrNull(fixture.logger, throwingValueDeserializer)
+
+    assertEquals(emptyMap(), actual)
+  }
+
+  @Test
+  fun `nextMapOfListOrNull keeps values before a failing value`() {
+    val actual =
+      getValuesReader("{\"good\": [{\"value\": \"one\"}], \"bad\": {\"value\": \"fail\"}}")
+        .nextMapOfListOrNull(fixture.logger, throwingValueDeserializer)
+
+    assertEquals(mapOf("good" to listOf("one")), actual)
+  }
+
+  @Test
+  fun `nextMapOfListOrNull keeps values after a failing value`() {
+    val actual =
+      getValuesReader("{\"bad\": {\"value\": \"fail\"}, \"good\": [{\"value\": \"two\"}]}")
+        .nextMapOfListOrNull(fixture.logger, throwingValueDeserializer)
+
+    assertEquals(mapOf("good" to listOf("two")), actual)
+  }
+
+  @Test
+  fun `nextMapOfListOrNull keeps nested values after skipValue consumes a failing element`() {
+    var callCount = 0
+    val deserializer =
+      JsonDeserializer<String> { reader, logger ->
+        if (callCount++ == 0) {
+          reader.skipValue()
+          throw IllegalStateException("intentional")
+        }
+        throwingValueDeserializer.deserialize(reader, logger)
+      }
+
+    val actual =
+      getValuesReader("{\"good\": [{\"value\": \"ignored\"}, {\"value\": \"two\"}]}")
+        .nextMapOfListOrNull(fixture.logger, deserializer)
+
+    assertEquals(mapOf("good" to listOf("two")), actual)
+  }
+
+  @Test
+  fun `nextListOrNull logs and aborts when recovery fails`() {
+    assertFailsWith<Exception> {
+      fixture
+        .getSut("[{\"value\": \"fail\"")
+        .nextListOrNull(fixture.logger, throwingValueDeserializer)
+    }
+
+    verify(fixture.logger)
+      .log(
+        eq(SentryLevel.ERROR),
+        eq("Stream unrecoverable, aborting list deserialization."),
+        any<Throwable>(),
+      )
+  }
+
+  @Test
+  fun `nextMapOrNull logs and aborts when recovery fails`() {
+    assertFailsWith<Exception> {
+      fixture
+        .getSut("{\"bad\": {\"value\": \"fail\"")
+        .nextMapOrNull(fixture.logger, throwingValueDeserializer)
+    }
+
+    verify(fixture.logger)
+      .log(
+        eq(SentryLevel.ERROR),
+        eq("Stream unrecoverable, aborting map deserialization."),
+        any<Throwable>(),
+      )
+  }
+
+  @Test
+  fun `nextMapOfListOrNull logs and aborts when recovery fails`() {
+    assertFailsWith<Exception> {
+      fixture
+        .getSut("{\"bad\": [{\"value\": \"fail\"")
+        .nextMapOfListOrNull(fixture.logger, throwingValueDeserializer)
+    }
+
+    verify(fixture.logger)
+      .log(
+        eq(SentryLevel.ERROR),
+        eq("Stream unrecoverable, aborting map-of-lists deserialization."),
+        any<Throwable>(),
+      )
+  }
+
+  @Test
+  fun `nextUnknown logs when recovery fails`() {
+    val unknown = mutableMapOf<String, Any>()
+    val reader = fixture.getSut("{\"key\": {\"value\": \"fail\"")
+    reader.beginObject()
+    val name = reader.nextName()
+
+    reader.nextUnknown(fixture.logger, unknown, name)
+
+    assertEquals(emptyMap(), unknown)
+    verify(fixture.logger)
+      .log(
+        eq(SentryLevel.ERROR),
+        any<Throwable>(),
+        eq("Error deserializing unknown key: %s"),
+        eq("key"),
+      )
+    verify(fixture.logger)
+      .log(
+        eq(SentryLevel.ERROR),
+        eq("Stream unrecoverable after unknown key deserialization failure."),
+        any<Throwable>(),
+      )
+    verifyNoMoreInteractions(fixture.logger)
+  }
+
   // nextDateOrNull
 
   @Test
diff --git a/sentry/src/test/java/io/sentry/util/MapObjectReaderTest.kt b/sentry/src/test/java/io/sentry/util/MapObjectReaderTest.kt
index 26991bd4937..e7ad9bc61e3 100644
--- a/sentry/src/test/java/io/sentry/util/MapObjectReaderTest.kt
+++ b/sentry/src/test/java/io/sentry/util/MapObjectReaderTest.kt
@@ -13,8 +13,8 @@ import java.util.Currency
 import java.util.Date
 import java.util.Locale
 import java.util.TimeZone
-import kotlin.test.Test
 import kotlin.test.assertEquals
+import org.junit.Test
 
 class MapObjectReaderTest {
   enum class BasicEnum {
@@ -39,9 +39,37 @@ class MapObjectReaderTest {
     }
   }
 
+  private val logger = NoOpLogger.getInstance()
+
+  private fun getValuesReader(value: Any): MapObjectReader =
+    MapObjectReader(linkedMapOf("values" to value)).apply {
+      beginObject()
+      nextName()
+    }
+
+  private fun serializableValue(value: String): Map<String, Any> = linkedMapOf("test" to value)
+
+  private fun partialSerializableValue(kind: String, value: String): Map<String, Any> =
+    linkedMapOf("test" to value, "kind" to kind)
+
+  private val partiallyFailingDeserializer =
+    JsonDeserializer<BasicSerializable> { reader, _ ->
+      val basicSerializable = BasicSerializable()
+      reader.beginObject()
+      if (reader.nextName() == "kind") {
+        if (reader.nextString() == "fail") {
+          throw IllegalStateException("intentional")
+        }
+      }
+      if (reader.nextName() == "test") {
+        basicSerializable.test = reader.nextString()
+      }
+      reader.endObject()
+      basicSerializable
+    }
+
   @Test
   fun `deserializes data correctly`() {
-    val logger = NoOpLogger.getInstance()
     val data = mutableMapOf<String, Any>()
     val writer = MapObjectWriter(data)
 
@@ -145,4 +173,179 @@ class MapObjectReaderTest {
     reader.nextNull()
     reader.endObject()
   }
+
+  @Test
+  fun `nextListOrNull returns empty list for empty list`() {
+    val actual =
+      getValuesReader(emptyList<String>()).nextListOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(emptyList(), actual)
+  }
+
+  @Test
+  fun `nextListOrNull skips a failing element`() {
+    val actual =
+      getValuesReader(listOf("fail")).nextListOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(emptyList(), actual)
+  }
+
+  @Test
+  fun `nextListOrNull keeps elements before a failing element`() {
+    val actual =
+      getValuesReader(listOf(serializableValue("one"), "fail"))
+        .nextListOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(listOf(BasicSerializable("one")), actual)
+  }
+
+  @Test
+  fun `nextListOrNull keeps elements after a failing element`() {
+    val actual =
+      getValuesReader(listOf("fail", serializableValue("two")))
+        .nextListOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(listOf(BasicSerializable("two")), actual)
+  }
+
+  @Test
+  fun `nextListOrNull keeps elements after a failing object followed by a primitive`() {
+    val reader =
+      getValuesReader(
+        listOf(
+          partialSerializableValue("fail", "bad"),
+          "oops",
+          partialSerializableValue("ok", "two"),
+        )
+      )
+
+    val actual = reader.nextListOrNull(logger, partiallyFailingDeserializer)
+
+    assertEquals(listOf(BasicSerializable("two")), actual)
+    assertEquals(JsonToken.END_OBJECT, reader.peek())
+  }
+
+  @Test
+  fun `nextMapOrNull returns empty map for empty map`() {
+    val actual =
+      getValuesReader(linkedMapOf<String, String>())
+        .nextMapOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(emptyMap(), actual)
+  }
+
+  @Test
+  fun `nextMapOrNull skips a failing value`() {
+    val actual =
+      getValuesReader(linkedMapOf("bad" to "fail"))
+        .nextMapOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(emptyMap(), actual)
+  }
+
+  @Test
+  fun `nextMapOrNull keeps values before a failing value`() {
+    val actual =
+      getValuesReader(linkedMapOf("bad" to "fail", "good" to serializableValue("one")))
+        .nextMapOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(mapOf("good" to BasicSerializable("one")), actual)
+  }
+
+  @Test
+  fun `nextMapOrNull keeps values after a failing value`() {
+    val actual =
+      getValuesReader(linkedMapOf("good" to serializableValue("two"), "bad" to "fail"))
+        .nextMapOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(mapOf("good" to BasicSerializable("two")), actual)
+  }
+
+  @Test
+  fun `nextMapOfListOrNull returns empty map for empty map`() {
+    val actual =
+      getValuesReader(linkedMapOf<String, List<String>>())
+        .nextMapOfListOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(emptyMap(), actual)
+  }
+
+  @Test
+  fun `nextMapOfListOrNull skips a failing value`() {
+    val actual =
+      getValuesReader(linkedMapOf("bad" to serializableValue("fail")))
+        .nextMapOfListOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(emptyMap(), actual)
+  }
+
+  @Test
+  fun `nextMapOfListOrNull keeps values before a failing value`() {
+    val actual =
+      getValuesReader(
+          linkedMapOf(
+            "bad" to serializableValue("fail"),
+            "good" to listOf(serializableValue("one")),
+          )
+        )
+        .nextMapOfListOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(mapOf("good" to listOf(BasicSerializable("one"))), actual)
+  }
+
+  @Test
+  fun `nextMapOfListOrNull keeps values after a failing value`() {
+    val actual =
+      getValuesReader(
+          linkedMapOf(
+            "good" to listOf(serializableValue("two")),
+            "bad" to serializableValue("fail"),
+          )
+        )
+        .nextMapOfListOrNull(logger, BasicSerializable.Deserializer())
+
+    assertEquals(mapOf("good" to listOf(BasicSerializable("two"))), actual)
+  }
+
+  @Test
+  fun `nextListOrNull keeps elements after a partially consumed failing element`() {
+    val actual =
+      getValuesReader(
+          listOf(partialSerializableValue("fail", "bad"), partialSerializableValue("ok", "two"))
+        )
+        .nextListOrNull(logger, partiallyFailingDeserializer)
+
+    assertEquals(listOf(BasicSerializable("two")), actual)
+  }
+
+  @Test
+  fun `nextMapOrNull keeps values before a partially consumed failing value`() {
+    val actual =
+      getValuesReader(
+          linkedMapOf(
+            "bad" to partialSerializableValue("fail", "bad"),
+            "good" to partialSerializableValue("ok", "two"),
+          )
+        )
+        .nextMapOrNull(logger, partiallyFailingDeserializer)
+
+    assertEquals(mapOf("good" to BasicSerializable("two")), actual)
+  }
+
+  @Test
+  fun `nextMapOfListOrNull keeps values before a partially consumed failing element`() {
+    val actual =
+      getValuesReader(
+          linkedMapOf(
+            "bad" to listOf(partialSerializableValue("fail", "bad")),
+            "good" to listOf(partialSerializableValue("ok", "two")),
+          )
+        )
+        .nextMapOfListOrNull(logger, partiallyFailingDeserializer)
+
+    assertEquals(
+      mapOf("bad" to emptyList<BasicSerializable>(), "good" to listOf(BasicSerializable("two"))),
+      actual,
+    )
+  }
 }

From 7bd7bbfef09b126fd4337c16ceb6d1997272452d Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Fri, 17 Apr 2026 07:40:12 +0200
Subject: [PATCH 104/391] fix changelog for unreleased SDK hang fix (#5298)

---
 CHANGELOG.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7e26f52e5dd..3600aeb640d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## 8.39.0
+## Unreleased
 
 ### Fixes
 
@@ -8,6 +8,11 @@
   - Failed collection values are now skipped so parsing can continue
   - Skipped collection values emit `WARNING` logs
   - Unknown-key failures and unrecoverable recovery failures emit `ERROR` logs
+
+## 8.39.0
+
+### Fixes
+
 - Fix ANR caused by `GestureDetectorCompat` Handler/MessageQueue lock contention in `SentryWindowCallback` ([#5138](https://github.com/getsentry/sentry-java/pull/5138))
 
 ### Internal

From d23b4b6a69a8936675206cb4b58b4b99d04c9293 Mon Sep 17 00:00:00 2001
From: adinauer <2542832+adinauer@users.noreply.github.com>
Date: Fri, 17 Apr 2026 06:07:15 +0000
Subject: [PATCH 105/391] release: 8.39.1

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3600aeb640d..af6310208c6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.39.1
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index 5266e49135d..aee4b497d0e 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.39.0
+versionName=8.39.1
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 5b1a06bd53650db11a9256a03309c1af9f8d76c6 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 17 Apr 2026 15:52:35 +0200
Subject: [PATCH 106/391] docs(readme): Link Maven Central shields to artifact
 pages (#5307)

---
 README.md | 104 +++++++++++++++++++++++++++---------------------------
 1 file changed, 52 insertions(+), 52 deletions(-)

diff --git a/README.md b/README.md
index 25fedc8217f..7d9ad7ba287 100644
--- a/README.md
+++ b/README.md
@@ -19,58 +19,58 @@ Sentry SDK for Java and Android
 
 | Packages                                | Maven Central                                                                                                                                                  | Minimum Android API Version |
 |-----------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------| ------- |
-| sentry-android                          | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android?style=for-the-badge&logo=sentry&color=green)                          | 21 |
-| sentry-android-core                     | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-core?style=for-the-badge&logo=sentry&color=green)                     | 21 |
-| sentry-android-distribution             | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-distribution?style=for-the-badge&logo=sentry&color=green)             | 21 |
-| sentry-android-ndk                      | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-ndk?style=for-the-badge&logo=sentry&color=green)                      | 21 |
-| sentry-android-timber                   | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-timber?style=for-the-badge&logo=sentry&color=green)                   | 21 |
-| sentry-android-fragment                 | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-fragment?style=for-the-badge&logo=sentry&color=green)                 | 21 |
-| sentry-android-navigation               | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-navigation?style=for-the-badge&logo=sentry&color=green)               | 21 |
-| sentry-android-sqlite                   | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-sqlite?style=for-the-badge&logo=sentry&color=green)                   | 21 |
-| sentry-android-replay                   | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-replay?style=for-the-badge&logo=sentry&color=green)                   | 26 |
-| sentry-compose-android                  | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-compose-android?style=for-the-badge&logo=sentry&color=green)                  | 21 |
-| sentry-compose-desktop                  | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-compose-desktop?style=for-the-badge&logo=sentry&color=green)                  | 
-| sentry-compose                          | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-compose?style=for-the-badge&logo=sentry&color=green)                          | 
-| sentry-apache-http-client-5             | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apache-http-client-5?style=for-the-badge&logo=sentry&color=green)             |
-| sentry                                  | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry?style=for-the-badge&logo=sentry&color=green)                                  | 21 |
-| sentry-jul                              | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-jul?style=for-the-badge&logo=sentry&color=green)                              |
-| sentry-jdbc                             | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-jdbc?style=for-the-badge&logo=sentry&color=green)                             |
-| sentry-apollo                           | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apollo?style=for-the-badge&logo=sentry&color=green)                           | 21 |
-| sentry-apollo-3                         | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apollo-3?style=for-the-badge&logo=sentry&color=green)                         | 21 |
-| sentry-apollo-4                         | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apollo-4?style=for-the-badge&logo=sentry&color=green)                         | 21 |
-| sentry-kotlin-extensions                | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-kotlin-extensions?style=for-the-badge&logo=sentry&color=green)                | 21 |
-| sentry-ktor-client                      | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-ktor-client?style=for-the-badge&logo=sentry&color=green)                      | 21 |
-| sentry-servlet                          | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-servlet?style=for-the-badge&logo=sentry&color=green)                          | |
-| sentry-servlet-jakarta                  | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-servlet-jakarta?style=for-the-badge&logo=sentry&color=green)                  | |
-| sentry-spring-boot                      | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot?style=for-the-badge&logo=sentry&color=green)                      |
-| sentry-spring-boot-jakarta              | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-jakarta?style=for-the-badge&logo=sentry&color=green)              |
-| sentry-spring-boot-4                    | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-4?style=for-the-badge&logo=sentry&color=green)                    |
-| sentry-spring-boot-4-starter            | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-4-starter?style=for-the-badge&logo=sentry&color=green)            |
-| sentry-spring-boot-starter              | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-starter?style=for-the-badge&logo=sentry&color=green)              |
-| sentry-spring-boot-starter-jakarta      | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-starter-jakarta?style=for-the-badge&logo=sentry&color=green)      |
-| sentry-spring                           | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring?style=for-the-badge&logo=sentry&color=green)                           |
-| sentry-spring-jakarta                   | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-jakarta?style=for-the-badge&logo=sentry&color=green)                   |
-| sentry-spring-7                         | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-7?style=for-the-badge&logo=sentry&color=green)                         |
-| sentry-logback                          | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-logback?style=for-the-badge&logo=sentry&color=green)                          |
-| sentry-log4j2                           | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-log4j2?style=for-the-badge&logo=sentry&color=green)                           |
-| sentry-bom                              | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-bom?style=for-the-badge&logo=sentry&color=green)                              |
-| sentry-graphql                          | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-graphql?style=for-the-badge&logo=sentry&color=green)                          |
-| sentry-graphql-core                     | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-graphql-core?style=for-the-badge&logo=sentry&color=green)                     |
-| sentry-graphql-22                       | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-graphql-22?style=for-the-badge&logo=sentry&color=green)                       |
-| sentry-jcache                           | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-jcache?style=for-the-badge&logo=sentry&color=green)                           |
-| sentry-quartz                           | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-quartz?style=for-the-badge&logo=sentry&color=green)                           |
-| sentry-openfeign                        | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-openfeign?style=for-the-badge&logo=sentry&color=green)                        |
-| sentry-openfeature                      | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-openfeature?style=for-the-badge&logo=sentry&color=green)                      |
-| sentry-launchdarkly-android             | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-launchdarkly-android?style=for-the-badge&logo=sentry&color=green)             |
-| sentry-launchdarkly-server              | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-launchdarkly-server?style=for-the-badge&logo=sentry&color=green)              |
-| sentry-opentelemetry-agent              | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-agent?style=for-the-badge&logo=sentry&color=green)              |
-| sentry-opentelemetry-agentcustomization | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-agentcustomization?style=for-the-badge&logo=sentry&color=green) |
-| sentry-opentelemetry-core               | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-core?style=for-the-badge&logo=sentry&color=green)               |
-| sentry-opentelemetry-otlp               | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-otlp?style=for-the-badge&logo=sentry&color=green)               |
-| sentry-opentelemetry-otlp-spring        | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-otlp-spring?style=for-the-badge&logo=sentry&color=green)        |
-| sentry-okhttp                           | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-okhttp?style=for-the-badge&logo=sentry&color=green)                           |
-| sentry-reactor                          | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-reactor?style=for-the-badge&logo=sentry&color=green)                          |
-| sentry-spotlight                        | ![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spotlight?style=for-the-badge&logo=sentry&color=green)                        |
+| sentry-android                          | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-android)                          | 21 |
+| sentry-android-core                     | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-core?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-android-core)                     | 21 |
+| sentry-android-distribution             | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-distribution?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-android-distribution)             | 21 |
+| sentry-android-ndk                      | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-ndk?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-android-ndk)                      | 21 |
+| sentry-android-timber                   | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-timber?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-android-timber)                   | 21 |
+| sentry-android-fragment                 | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-fragment?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-android-fragment)                 | 21 |
+| sentry-android-navigation               | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-navigation?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-android-navigation)               | 21 |
+| sentry-android-sqlite                   | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-sqlite?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-android-sqlite)                   | 21 |
+| sentry-android-replay                   | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-android-replay?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-android-replay)                   | 26 |
+| sentry-compose-android                  | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-compose-android?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-compose-android)                  | 21 |
+| sentry-compose-desktop                  | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-compose-desktop?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-compose-desktop)                  | 
+| sentry-compose                          | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-compose?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-compose)                          | 
+| sentry-apache-http-client-5             | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apache-http-client-5?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-apache-http-client-5)             |
+| sentry                                  | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry)                                  | 21 |
+| sentry-jul                              | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-jul?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-jul)                              |
+| sentry-jdbc                             | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-jdbc?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-jdbc)                             |
+| sentry-apollo                           | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apollo?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-apollo)                           | 21 |
+| sentry-apollo-3                         | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apollo-3?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-apollo-3)                         | 21 |
+| sentry-apollo-4                         | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apollo-4?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-apollo-4)                         | 21 |
+| sentry-kotlin-extensions                | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-kotlin-extensions?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-kotlin-extensions)                | 21 |
+| sentry-ktor-client                      | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-ktor-client?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-ktor-client)                      | 21 |
+| sentry-servlet                          | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-servlet?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-servlet)                          | |
+| sentry-servlet-jakarta                  | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-servlet-jakarta?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-servlet-jakarta)                  | |
+| sentry-spring-boot                      | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spring-boot)                      |
+| sentry-spring-boot-jakarta              | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-jakarta?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spring-boot-jakarta)              |
+| sentry-spring-boot-4                    | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-4?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spring-boot-4)                    |
+| sentry-spring-boot-4-starter            | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-4-starter?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spring-boot-4-starter)            |
+| sentry-spring-boot-starter              | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-starter?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spring-boot-starter)              |
+| sentry-spring-boot-starter-jakarta      | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-boot-starter-jakarta?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spring-boot-starter-jakarta)      |
+| sentry-spring                           | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spring)                           |
+| sentry-spring-jakarta                   | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-jakarta?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spring-jakarta)                   |
+| sentry-spring-7                         | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spring-7?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spring-7)                         |
+| sentry-logback                          | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-logback?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-logback)                          |
+| sentry-log4j2                           | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-log4j2?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-log4j2)                           |
+| sentry-bom                              | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-bom?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-bom)                              |
+| sentry-graphql                          | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-graphql?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-graphql)                          |
+| sentry-graphql-core                     | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-graphql-core?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-graphql-core)                     |
+| sentry-graphql-22                       | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-graphql-22?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-graphql-22)                       |
+| sentry-jcache                           | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-jcache?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-jcache)                           |
+| sentry-quartz                           | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-quartz?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-quartz)                           |
+| sentry-openfeign                        | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-openfeign?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-openfeign)                        |
+| sentry-openfeature                      | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-openfeature?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-openfeature)                      |
+| sentry-launchdarkly-android             | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-launchdarkly-android?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-launchdarkly-android)             |
+| sentry-launchdarkly-server              | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-launchdarkly-server?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-launchdarkly-server)              |
+| sentry-opentelemetry-agent              | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-agent?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-agent)              |
+| sentry-opentelemetry-agentcustomization | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-agentcustomization?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-agentcustomization) |
+| sentry-opentelemetry-core               | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-core?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-core)               |
+| sentry-opentelemetry-otlp               | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-otlp?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-otlp)               |
+| sentry-opentelemetry-otlp-spring        | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-otlp-spring?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-otlp-spring)        |
+| sentry-okhttp                           | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-okhttp?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-okhttp)                           |
+| sentry-reactor                          | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-reactor?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-reactor)                          |
+| sentry-spotlight                        | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-spotlight?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-spotlight)                        |
 
 # Releases
 

From a5924eba1f6f39ff37c32f00bb8d590474f2131b Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Mon, 20 Apr 2026 15:03:07 +0200
Subject: [PATCH 107/391] fix(ci): Remove flaky Android 14 configuration from
 CI workflow (#5295)

The Android 14 emulator seems to often silently drop the notification, causing the tests to fail. Let's remove it for now.
---
 .github/workflows/integration-tests-ui-critical.yml | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 46b9665a099..62d7d83466b 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -67,10 +67,6 @@ jobs:
             target: google_apis
             channel: canary # Necessary for ATDs
             arch: x86_64
-          - api-level: 34 # Android 14
-            target: google_apis
-            channel: canary # Necessary for ATDs
-            arch: x86_64
           - api-level: 35 # Android 15
             target: google_apis
             channel: canary # Necessary for ATDs

From 7392db311a82adae5b3157f3b50971d095fa0b7d Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 20 Apr 2026 15:39:37 +0200
Subject: [PATCH 108/391] chore(deps): update Native SDK to v0.13.7 (#5296)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 8 ++++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index af6310208c6..ad76dd5388b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+### Dependencies
+
+- Bump Native SDK from v0.13.6 to v0.13.7 ([#5296](https://github.com/getsentry/sentry-java/pull/5296))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0137)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.13.6...0.13.7)
+
 ## 8.39.1
 
 ### Fixes
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index d02e3249df7..3c62935b805 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -151,7 +151,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.6" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.7" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 6a9020cf1d070f39554fc2e07588475a359c8599 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 20 Apr 2026 18:29:14 +0200
Subject: [PATCH 109/391] build(deps): bump github/codeql-action from 4.35.1 to
 4.35.2 (#5308)

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 4.35.1 to 4.35.2.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/c10b8064de6f491fea524254123dbe5e09572f13...95e58e9a2cdfd71adc6e0353d5c52f41a045d225)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-version: 4.35.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql-analysis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 6b30f064c49..acb0483b5ba 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@c10b8064de6f491fea524254123dbe5e09572f13 # pin@v2
+        uses: github/codeql-action/init@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@c10b8064de6f491fea524254123dbe5e09572f13 # pin@v2
+        uses: github/codeql-action/analyze@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # pin@v2

From 2dffe01728e47c0641dc7baec1f01a286402ded6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 20 Apr 2026 18:29:50 +0200
Subject: [PATCH 110/391] build(deps): bump getsentry/craft from 2.25.2 to
 2.25.4 (#5309)

Bumps [getsentry/craft](https://github.com/getsentry/craft) from 2.25.2 to 2.25.4.
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/ba01e596c4a4c07692f0de10b0d4fe05f3dd0292...97d0c4286f32a80d09c8b89366d762fecc3e27b6)

---
updated-dependencies:
- dependency-name: getsentry/craft
  dependency-version: 2.25.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index d2b9eaf45a2..177e8810a1b 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@ba01e596c4a4c07692f0de10b0d4fe05f3dd0292 # v2
+        uses: getsentry/craft@97d0c4286f32a80d09c8b89366d762fecc3e27b6 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From e442d80a400ece84ad14b192665327e2381ebd78 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 20 Apr 2026 18:30:41 +0200
Subject: [PATCH 111/391] build(deps): bump actions/cache from 5.0.4 to 5.0.5
 (#5310)

Bumps [actions/cache](https://github.com/actions/cache) from 5.0.4 to 5.0.5.
- [Release notes](https://github.com/actions/cache/releases)
- [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md)
- [Commits](https://github.com/actions/cache/compare/668228422ae6a00e4ad889ee87cd7109ec5666a7...27d5ce7f107fe9357f9df03efb73ab90386fccae)

---
updated-dependencies:
- dependency-name: actions/cache
  dependency-version: 5.0.5
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 2 +-
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index d288bbef8ae..33ba8ae93e8 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -50,7 +50,7 @@ jobs:
           sudo udevadm trigger --name-match=kvm
 
       - name: AVD cache
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
         id: avd-cache
         with:
           path: |
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 5debd3ad5a2..089913c9727 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -31,7 +31,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index dee3ddb6652..b5457751809 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -92,7 +92,7 @@ jobs:
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
-      - uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
+      - uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
         id: app-plain-cache
         with:
           path: sentry-android-integration-tests/test-app-plain/build/outputs/apk/release/test-app-plain-release.apk
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index 615d447cbf2..1fd6c5c2c09 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -30,7 +30,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 62d7d83466b..4d6c952a161 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -86,7 +86,7 @@ jobs:
           sudo udevadm trigger --name-match=kvm
 
       - name: AVD cache
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
         id: avd-cache
         with:
           path: |
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 9ac07b7b3ee..dfe742087d6 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -50,7 +50,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 963b6976cc2..577f0144179 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -50,7 +50,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 97fd6476fed..5246cf90cdd 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -50,7 +50,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5
+        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}

From 35c8ffa9a70c59ca23c155ef416e3de6e05cf65c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 20 Apr 2026 18:31:30 +0200
Subject: [PATCH 112/391] build(deps): bump
 getsentry/craft/.github/workflows/changelog-preview.yml from 2.25.2 to 2.25.4
 (#5311)

Bumps [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) from 2.25.2 to 2.25.4.
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/ba01e596c4a4c07692f0de10b0d4fe05f3dd0292...97d0c4286f32a80d09c8b89366d762fecc3e27b6)

---
updated-dependencies:
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.25.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/changelog-preview.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index f22a34cba7c..d8ea91d129a 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@ba01e596c4a4c07692f0de10b0d4fe05f3dd0292 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@97d0c4286f32a80d09c8b89366d762fecc3e27b6 # v2
     secrets: inherit

From 16a07c40ba6ffca0e7df663453beec20661e5142 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Mon, 20 Apr 2026 18:35:38 +0200
Subject: [PATCH 113/391] fix(compose): `NoSuchMethodError` for
 `LayoutCoordinates.localBoundingBoxOf$default` on Compose touch dispatch with
 AGP 8.13 and `minSdk < 24` (#5302)

* fix(compose): pass clipBounds explicitly to avoid D8 desugaring mismatch

* changelog
---
 CHANGELOG.md                                                  | 4 ++++
 .../src/main/java/io/sentry/android/replay/util/Nodes.kt      | 4 +++-
 .../kotlin/io/sentry/compose/SentryComposeHelper.kt           | 4 +++-
 3 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ad76dd5388b..5a7e290e1fe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+
+- Fix `NoSuchMethodError` for `LayoutCoordinates.localBoundingBoxOf$default` on Compose touch dispatch with AGP 8.13 and `minSdk < 24` ([#5302](https://github.com/getsentry/sentry-java/pull/5302))
+
 ### Dependencies
 
 - Bump Native SDK from v0.13.6 to v0.13.7 ([#5296](https://github.com/getsentry/sentry-java/pull/5296))
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
index cd9e3dd208a..2882b2113b8 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
@@ -167,7 +167,9 @@ internal fun LayoutCoordinates.boundsInWindow(rootCoordinates: LayoutCoordinates
   val rootWidth = root.size.width.toFloat()
   val rootHeight = root.size.height.toFloat()
 
-  val bounds = root.localBoundingBoxOf(this)
+  // pass clipBounds explicitly to avoid the `localBoundingBoxOf$default` bridge that AGP 8.13's D8
+  // desugars inconsistently on minSdk < 24
+  val bounds = root.localBoundingBoxOf(this, true)
   val boundsLeft = bounds.left.fastCoerceIn(0f, rootWidth)
   val boundsTop = bounds.top.fastCoerceIn(0f, rootHeight)
   val boundsRight = bounds.right.fastCoerceIn(0f, rootWidth)
diff --git a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryComposeHelper.kt b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryComposeHelper.kt
index 1f93f758756..10d02103ba1 100644
--- a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryComposeHelper.kt
+++ b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryComposeHelper.kt
@@ -86,7 +86,9 @@ public fun LayoutCoordinates.boundsInWindow(rootCoordinates: LayoutCoordinates?)
   val rootWidth = root.size.width.toFloat()
   val rootHeight = root.size.height.toFloat()
 
-  val bounds = root.localBoundingBoxOf(this)
+  // pass clipBounds explicitly to avoid the `localBoundingBoxOf$default` bridge that AGP 8.13's D8
+  // desugars inconsistently on minSdk < 24
+  val bounds = root.localBoundingBoxOf(this, true)
   val boundsLeft = bounds.left.fastCoerceIn(0f, rootWidth)
   val boundsTop = bounds.top.fastCoerceIn(0f, rootHeight)
   val boundsRight = bounds.right.fastCoerceIn(0f, rootWidth)

From 0220a5c65e646d44283a513e5a3bdc60d7d79d87 Mon Sep 17 00:00:00 2001
From: "fix-it-felix-sentry[bot]"
 <260785270+fix-it-felix-sentry[bot]@users.noreply.github.com>
Date: Mon, 20 Apr 2026 20:01:30 +0200
Subject: [PATCH 114/391] fix(security): Add integrity verification before
 chmod +x in btrace-perfetto skill (#5297)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(security): Add integrity verification before chmod +x in btrace-perfetto skill

Add validation to verify downloaded trace_processor file is a valid executable
before making it executable. This prevents potential execution of malicious or
corrupted downloads.

Changes:
- Verify file exists and has non-zero size
- Check file type to confirm it's an executable
- Remove file and exit with error if validation fails
- Only chmod +x after successful verification

Fixes: https://linear.app/getsentry/issue/EME-1060
Parent ticket: https://linear.app/getsentry/issue/VULN-1513

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* fix(security): Verify magic bytes instead of file(1) for trace_processor

The previous check ran `file /tmp/trace_processor | grep -q executable` after
downloading the Perfetto trace_processor wrapper. That is unreliable in both
directions:

- get.perfetto.dev currently serves a Python wrapper script (#!/usr/bin/env
  python3). Depending on the file(1) version and magic database, shebang
  scripts may be reported as "Python script, ASCII text" without the word
  "executable", failing the check.
- If Perfetto ever switches to native PIE ELF binaries, older file(1) versions
  (< 5.36) report them as "shared object" without "executable", also failing.

In both cases the valid download was deleted and the workflow aborted.

Check magic bytes directly instead — shebang (#!), ELF, or Mach-O — which is
stable across platforms and file(1) versions. Also add `curl --fail` so HTTP
errors do not leave a partial/HTML response on disk that would then be
validated.

Refs LINEAR-EME-1060
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: fix-it-felix-sentry[bot] <260785270+fix-it-felix-sentry[bot]@users.noreply.github.com>
Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 .claude/skills/btrace-perfetto/SKILL.md | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/.claude/skills/btrace-perfetto/SKILL.md b/.claude/skills/btrace-perfetto/SKILL.md
index 7cbea4841ee..8d9e5a6bca1 100644
--- a/.claude/skills/btrace-perfetto/SKILL.md
+++ b/.claude/skills/btrace-perfetto/SKILL.md
@@ -22,7 +22,26 @@ Before starting, verify:
    ```
 3. **Perfetto trace_processor**: Check if `/tmp/trace_processor` exists. If not, download it:
    ```bash
-   curl -sL "https://get.perfetto.dev/trace_processor" -o /tmp/trace_processor && chmod +x /tmp/trace_processor
+   # Download trace_processor (--fail ensures HTTP errors don't leave a file behind)
+   curl -sSL --fail "https://get.perfetto.dev/trace_processor" -o /tmp/trace_processor
+
+   # Verify magic bytes directly — file(1) output is too inconsistent across
+   # versions/platforms to rely on for scripts or PIE binaries.
+   magic=$(head -c 4 /tmp/trace_processor 2>/dev/null | od -An -vtx1 -N4 | tr -d ' \n')
+   case "$magic" in
+     2321*)                               ;; # #! shebang (script)
+     7f454c46)                            ;; # ELF (Linux)
+     cffaedfe|cefaedfe|feedfacf|feedface) ;; # Mach-O (macOS)
+     cafebabe)                            ;; # Mach-O universal
+     *)
+       echo "Error: Downloaded file is not a valid script or executable (magic: ${magic:-empty})"
+       rm -f /tmp/trace_processor
+       exit 1
+       ;;
+   esac
+
+   # Make executable only after verification
+   chmod +x /tmp/trace_processor
    ```
 4. **Device ABI**: Run `adb shell getprop ro.product.cpu.abi` — btrace only supports arm64-v8a and armeabi-v7a (no x86/x86_64)
 

From 40234a987c6bad214db8d58a919ea25404dc4c19 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Wed, 22 Apr 2026 12:18:28 +0200
Subject: [PATCH 115/391] fix(sentry-okhttp): Skip synthetic 504 for
 FORCE_CACHE cache misses (#5299)

* fix(sentry-okhttp): Skip synthetic 504 for FORCE_CACHE cache misses

OkHttp's CacheInterceptor synthesizes a 504 "Unsatisfiable Request"
response when a request with `only-if-cached` (e.g. CacheControl.FORCE_CACHE)
misses the cache. This is not a real server error, so don't capture it
as a failed request event.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: Update changelog PR link to #5299

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../sentry/okhttp/SentryOkHttpInterceptor.kt  |  9 +++++++
 .../okhttp/SentryOkHttpInterceptorTest.kt     | 25 +++++++++++++++++++
 3 files changed, 35 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a7e290e1fe..13f27480154 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Fixes
 
 - Fix `NoSuchMethodError` for `LayoutCoordinates.localBoundingBoxOf$default` on Compose touch dispatch with AGP 8.13 and `minSdk < 24` ([#5302](https://github.com/getsentry/sentry-java/pull/5302))
+- Fix reporting OkHttp's synthetic 504 "Unsatisfiable Request" responses as errors for `CacheControl.FORCE_CACHE` cache misses ([#5299](https://github.com/getsentry/sentry-java/pull/5299))
 
 ### Dependencies
 
diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index 6e20ecbcdb8..ea8fdb44159 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -58,6 +58,8 @@ public open class SentryOkHttpInterceptor(
   private val failedRequestTargets: List<String> = listOf(DEFAULT_PROPAGATION_TARGETS),
 ) : Interceptor {
   private companion object {
+    private const val HTTP_GATEWAY_TIMEOUT = 504
+
     init {
       SentryIntegrationPackageStorage.getInstance()
         .addPackage("maven:io.sentry:sentry-okhttp", BuildConfig.VERSION_NAME)
@@ -386,6 +388,13 @@ public open class SentryOkHttpInterceptor(
       return false
     }
 
+    // A 504 on an only-if-cached (e.g. CacheControl.FORCE_CACHE) request is a synthetic
+    // cache-miss response generated by OkHttp's CacheInterceptor, not a real server error,
+    // so don't report it. See https://square.github.io/okhttp/recipes/#response-caching-kt-java
+    if (response.code == HTTP_GATEWAY_TIMEOUT && request.cacheControl.onlyIfCached) {
+      return false
+    }
+
     return true
   }
 
diff --git a/sentry-okhttp/src/test/java/io/sentry/okhttp/SentryOkHttpInterceptorTest.kt b/sentry-okhttp/src/test/java/io/sentry/okhttp/SentryOkHttpInterceptorTest.kt
index 6e8b8548731..9f7d8bc18fb 100644
--- a/sentry-okhttp/src/test/java/io/sentry/okhttp/SentryOkHttpInterceptorTest.kt
+++ b/sentry-okhttp/src/test/java/io/sentry/okhttp/SentryOkHttpInterceptorTest.kt
@@ -31,6 +31,7 @@ import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 import kotlin.test.fail
+import okhttp3.CacheControl
 import okhttp3.EventListener
 import okhttp3.Interceptor
 import okhttp3.MediaType.Companion.toMediaType
@@ -541,6 +542,30 @@ class SentryOkHttpInterceptorTest {
       )
   }
 
+  @Test
+  fun `does not capture a synthetic 504 from OkHttp for a FORCE_CACHE cache miss`() {
+    // No cache is configured on the client, so FORCE_CACHE is guaranteed to miss and
+    // OkHttp's CacheInterceptor will synthesize a 504 "Unsatisfiable Request" response.
+    val sut = fixture.getSut(captureFailedRequests = true)
+    val request =
+      Request.Builder()
+        .url(fixture.server.url("/hello"))
+        .cacheControl(CacheControl.FORCE_CACHE)
+        .build()
+    val response = sut.newCall(request).execute()
+
+    assertEquals(504, response.code)
+    verify(fixture.scopes, never()).captureEvent(any(), any<Hint>())
+  }
+
+  @Test
+  fun `captures a real 504 when onlyIfCached is not set`() {
+    val sut = fixture.getSut(captureFailedRequests = true, httpStatusCode = 504)
+    sut.newCall(getRequest()).execute()
+
+    verify(fixture.scopes).captureEvent(any(), any<Hint>())
+  }
+
   @SuppressWarnings("SwallowedException")
   @Test
   fun `does not capture an error even if it throws`() {

From 952b180c6fffa6995fddbb3b638f0074d60a9500 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 22 Apr 2026 15:22:22 +0200
Subject: [PATCH 116/391] fix(gestures): Prevent duplicate ui.click breadcrumbs
 from buried window callbacks (#5300)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(user-interaction): Restore window callbacks on close and dedup instrumentation via WeakHashMap

Track wrapped windows in a thread-safe WeakHashMap so close() can restore each window's original callback chain, preventing an orphaned SentryWindowCallback from persisting after Sentry.close(). Also handle the case where another wrapper (e.g. Session Replay) has been installed on top of ours — we skip chain mutation but still invoke stopTracking() to release resources. Guards against racing lifecycle callbacks (main thread) and close() (possibly bg thread).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(replay): Track wrapped windows and inert buried recorders on stop

Track wrapped windows in a WeakHashMap so GestureRecorder skips re-wrapping already-instrumented windows and can locate its own recorder even when another wrapper (e.g. UserInteractionIntegration) has been installed on top of it. When our wrapper is buried in the callback chain, inert() it instead of mutating the chain so unrelated instrumentation isn't broken; the next replay session wraps on top with a fresh active recorder.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* changelog

* fix(user-interaction): Inert buried SentryWindowCallback and drop its cache entry on stop

Two follow-ups to the buried-wrapper path:

- stopTracking() now sets an inert flag that short-circuits handleTouchEvent, so a SentryWindowCallback that can't be cut out of the chain stops forwarding events to its gesture detector and listener. Without this, the "stopped" wrapper kept emitting ui.click breadcrumbs, so as soon as a fresh wrapper was installed on top the duplicates came back.
- unwrapWindow removes the wrapped window from the tracking map in the buried path too. Previously only the top-of-chain path cleared it, which meant the next startTracking() found a stale (but alive, since the inert wrapper is still referenced by the chain) entry and returned early, permanently losing gesture tracking for that window.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../core/UserInteractionIntegration.java      | 67 +++++++++++++++++--
 .../gestures/SentryWindowCallback.java        |  8 +++
 .../core/UserInteractionIntegrationTest.kt    | 64 ++++++++++++++++--
 .../gestures/SentryWindowCallbackTest.kt      | 14 ++++
 .../replay/gestures/GestureRecorder.kt        | 43 ++++++++++--
 .../replay/gestures/GestureRecorderTest.kt    | 44 ++++++++++--
 7 files changed, 217 insertions(+), 24 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 13f27480154..f71dedaba95 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -27,6 +27,7 @@
 ### Fixes
 
 - Fix ANR caused by `GestureDetectorCompat` Handler/MessageQueue lock contention in `SentryWindowCallback` ([#5138](https://github.com/getsentry/sentry-java/pull/5138))
+- Fix duplicate `ui.click` breadcrumbs when another `Window.Callback` wraps `SentryWindowCallback` ([#5300](https://github.com/getsentry/sentry-java/pull/5300))
 
 ### Internal
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/UserInteractionIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/UserInteractionIntegration.java
index c0dd3f9eb71..0d77625c718 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/UserInteractionIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/UserInteractionIntegration.java
@@ -18,6 +18,9 @@
 import io.sentry.util.Objects;
 import java.io.Closeable;
 import java.io.IOException;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.WeakHashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -30,6 +33,16 @@ public final class UserInteractionIntegration
 
   private final boolean isAndroidxLifecycleAvailable;
 
+  // WeakReference value, because the callback chain strongly references the wrapper — a strong
+  // value would prevent the window from ever being GC'd.
+  //
+  // All access must be guarded by wrappedWindowsLock — lifecycle callbacks fire on the main
+  // thread, but close() may be called from a background thread (e.g. Sentry.close()).
+  private final @NotNull WeakHashMap<Window, WeakReference<SentryWindowCallback>> wrappedWindows =
+      new WeakHashMap<>();
+
+  private final @NotNull Object wrappedWindowsLock = new Object();
+
   public UserInteractionIntegration(
       final @NotNull Application application, final @NotNull io.sentry.util.LoadClass classLoader) {
     this.application = Objects.requireNonNull(application, "Application is required");
@@ -47,19 +60,26 @@ private void startTracking(final @NotNull Activity activity) {
     }
 
     if (scopes != null && options != null) {
+      synchronized (wrappedWindowsLock) {
+        final @Nullable WeakReference<SentryWindowCallback> cached = wrappedWindows.get(window);
+        if (cached != null && cached.get() != null) {
+          return;
+        }
+      }
+
       Window.Callback delegate = window.getCallback();
       if (delegate == null) {
         delegate = new NoOpWindowCallback();
       }
 
-      if (delegate instanceof SentryWindowCallback) {
-        // already instrumented
-        return;
-      }
-
       final SentryGestureListener gestureListener =
           new SentryGestureListener(activity, scopes, options);
-      window.setCallback(new SentryWindowCallback(delegate, activity, gestureListener, options));
+      final SentryWindowCallback wrapper =
+          new SentryWindowCallback(delegate, activity, gestureListener, options);
+      window.setCallback(wrapper);
+      synchronized (wrappedWindowsLock) {
+        wrappedWindows.put(window, new WeakReference<>(wrapper));
+      }
     }
   }
 
@@ -71,7 +91,10 @@ private void stopTracking(final @NotNull Activity activity) {
       }
       return;
     }
+    unwrapWindow(window);
+  }
 
+  private void unwrapWindow(final @NotNull Window window) {
     final Window.Callback current = window.getCallback();
     if (current instanceof SentryWindowCallback) {
       ((SentryWindowCallback) current).stopTracking();
@@ -80,6 +103,23 @@ private void stopTracking(final @NotNull Activity activity) {
       } else {
         window.setCallback(((SentryWindowCallback) current).getDelegate());
       }
+      synchronized (wrappedWindowsLock) {
+        wrappedWindows.remove(window);
+      }
+      return;
+    }
+
+    // Another wrapper (e.g. Session Replay) sits on top of ours — cutting it out of the chain
+    // would break its instrumentation, so we leave the chain alone and just call stopTracking()
+    // to release our resources. The upstream wrapper holds a reference to ours, so it'll be
+    // GC'd whenever that upstream holder is (typically when the window is destroyed).
+    final @Nullable SentryWindowCallback ours;
+    synchronized (wrappedWindowsLock) {
+      final @Nullable WeakReference<SentryWindowCallback> cached = wrappedWindows.remove(window);
+      ours = cached != null ? cached.get() : null;
+    }
+    if (ours != null) {
+      ours.stopTracking();
     }
   }
 
@@ -146,6 +186,21 @@ public void register(@NotNull IScopes scopes, @NotNull SentryOptions options) {
   public void close() throws IOException {
     application.unregisterActivityLifecycleCallbacks(this);
 
+    // Restore original callbacks so a subsequent Sentry.init() starts from a clean chain instead
+    // of wrapping on top of our orphaned callback.
+    final ArrayList<Window> snapshot;
+    synchronized (wrappedWindowsLock) {
+      snapshot = new ArrayList<>(wrappedWindows.keySet());
+    }
+    for (final Window window : snapshot) {
+      if (window != null) {
+        unwrapWindow(window);
+      }
+    }
+    synchronized (wrappedWindowsLock) {
+      wrappedWindows.clear();
+    }
+
     if (options != null) {
       options.getLogger().log(SentryLevel.DEBUG, "UserInteractionIntegration removed.");
     }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
index 557cd4e7a29..e69756e506a 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
@@ -19,6 +19,10 @@ public final class SentryWindowCallback extends WindowCallbackAdapter {
   private final @Nullable SentryOptions options;
   private final @NotNull MotionEventObtainer motionEventObtainer;
 
+  // When we can't be removed from the callback chain (see UserInteractionIntegration),
+  // stopTracking() flips this so handleTouchEvent short-circuits.
+  private volatile boolean inert;
+
   public SentryWindowCallback(
       final @NotNull Window.Callback delegate,
       final @NotNull Context context,
@@ -64,6 +68,9 @@ public boolean dispatchTouchEvent(final @Nullable MotionEvent motionEvent) {
   }
 
   private void handleTouchEvent(final @NotNull MotionEvent motionEvent) {
+    if (inert) {
+      return;
+    }
     gestureDetector.onTouchEvent(motionEvent);
     int action = motionEvent.getActionMasked();
     if (action == MotionEvent.ACTION_UP) {
@@ -72,6 +79,7 @@ private void handleTouchEvent(final @NotNull MotionEvent motionEvent) {
   }
 
   public void stopTracking() {
+    inert = true;
     gestureListener.stopTracing(SpanStatus.CANCELLED);
     gestureDetector.release();
   }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/UserInteractionIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/UserInteractionIntegrationTest.kt
index f558841e6f5..8f20dbb1539 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/UserInteractionIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/UserInteractionIntegrationTest.kt
@@ -14,7 +14,7 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertIs
 import kotlin.test.assertIsNot
-import kotlin.test.assertNotEquals
+import kotlin.test.assertNotSame
 import kotlin.test.assertSame
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
@@ -149,15 +149,63 @@ class UserInteractionIntegrationTest {
   }
 
   @Test
-  fun `does not instrument if the callback is already ours`() {
-    val existingCallback =
-      SentryWindowCallback(NoOpWindowCallback(), fixture.activity, mock(), mock())
-    val sut = fixture.getSut(existingCallback)
+  fun `resume after buried pause installs a fresh wrapper on top`() {
+    val sut = fixture.getSut()
+    sut.register(fixture.scopes, fixture.options)
+
+    sut.onActivityResumed(fixture.activity)
+    val originalSentryCallback = fixture.window.callback
+    assertIs<SentryWindowCallback>(originalSentryCallback)
+
+    // Third-party wraps on top of us mid-activity.
+    val outerWrapper = WrapperCallback(originalSentryCallback)
+    fixture.window.callback = outerWrapper
+
+    sut.onActivityPaused(fixture.activity)
+    sut.onActivityResumed(fixture.activity)
+
+    val newTop = fixture.window.callback
+    assertIs<SentryWindowCallback>(newTop)
+    assertNotSame(originalSentryCallback, newTop)
+    assertSame(outerWrapper, newTop.delegate)
+  }
+
+  @Test
+  fun `close unwraps windows so re-init does not double-wrap`() {
+    val mockCallback = mock<Window.Callback>()
+    fixture.window.callback = mockCallback
 
+    val sutA = fixture.getSut()
+    sutA.register(fixture.scopes, fixture.options)
+    sutA.onActivityResumed(fixture.activity)
+    assertIs<SentryWindowCallback>(fixture.window.callback)
+
+    sutA.close()
+    assertSame(mockCallback, fixture.window.callback)
+
+    val sutB = UserInteractionIntegration(fixture.application, fixture.loadClass)
+    sutB.register(fixture.scopes, fixture.options)
+    sutB.onActivityResumed(fixture.activity)
+
+    val newWrapper = fixture.window.callback
+    assertIs<SentryWindowCallback>(newWrapper)
+    assertSame(mockCallback, newWrapper.delegate)
+  }
+
+  @Test
+  fun `paused with another wrapper on top does not cut it out of the chain`() {
+    val sut = fixture.getSut()
     sut.register(fixture.scopes, fixture.options)
+
     sut.onActivityResumed(fixture.activity)
+    val sentryCallback = fixture.window.callback as SentryWindowCallback
+
+    val outerWrapper = WrapperCallback(sentryCallback)
+    fixture.window.callback = outerWrapper
 
-    assertNotEquals(existingCallback, (fixture.window.callback as SentryWindowCallback).delegate)
+    sut.onActivityPaused(fixture.activity)
+
+    assertSame(outerWrapper, fixture.window.callback)
   }
 
   @Test
@@ -205,3 +253,7 @@ class UserInteractionIntegrationTest {
 private class EmptyActivity : Activity(), LifecycleOwner {
   override val lifecycle: Lifecycle = mock<Lifecycle>()
 }
+
+/** Simulates a third-party callback wrapper (e.g. Session Replay's FixedWindowCallback). */
+private open class WrapperCallback(@JvmField val delegate: Window.Callback) :
+  Window.Callback by delegate
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryWindowCallbackTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryWindowCallbackTest.kt
index 8afc1b39304..be0438d9345 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryWindowCallbackTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryWindowCallbackTest.kt
@@ -82,4 +82,18 @@ class SentryWindowCallbackTest {
 
     verify(fixture.gestureDetector, never()).onTouchEvent(any())
   }
+
+  @Test
+  fun `after stopTracking does not forward touches to detector or listener`() {
+    val event = mock<MotionEvent> { whenever(it.actionMasked).thenReturn(MotionEvent.ACTION_UP) }
+    val sut = fixture.getSut()
+
+    sut.stopTracking()
+    sut.dispatchTouchEvent(event)
+
+    verify(fixture.gestureDetector, never()).onTouchEvent(any())
+    verify(fixture.gestureListener, never()).onUp(any())
+    // super.dispatchTouchEvent still delegates to the wrapped delegate so the chain keeps working.
+    verify(fixture.delegate).dispatchTouchEvent(event)
+  }
 }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/gestures/GestureRecorder.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/gestures/GestureRecorder.kt
index 945a0be5156..cee75fb06c0 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/gestures/GestureRecorder.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/gestures/GestureRecorder.kt
@@ -11,6 +11,7 @@ import io.sentry.android.replay.phoneWindow
 import io.sentry.android.replay.util.FixedWindowCallback
 import io.sentry.util.AutoClosableReentrantLock
 import java.lang.ref.WeakReference
+import java.util.WeakHashMap
 
 internal class GestureRecorder(
   private val options: SentryOptions,
@@ -19,6 +20,11 @@ internal class GestureRecorder(
   private val rootViews = ArrayList<WeakReference<View>>()
   private val rootViewsLock = AutoClosableReentrantLock()
 
+  // WeakReference value, because the callback chain strongly references the wrapper — a strong
+  // value would prevent the window from ever being GC'd.
+  private val wrappedWindows = WeakHashMap<Window, WeakReference<SentryReplayGestureRecorder>>()
+  private val wrappedWindowsLock = AutoClosableReentrantLock()
+
   override fun onRootViewsChanged(root: View, added: Boolean) {
     rootViewsLock.acquire().use {
       if (added) {
@@ -45,10 +51,16 @@ internal class GestureRecorder(
       return
     }
 
-    val delegate = window.callback
-    if (delegate !is SentryReplayGestureRecorder) {
-      window.callback = SentryReplayGestureRecorder(options, touchRecorderCallback, delegate)
+    wrappedWindowsLock.acquire().use {
+      if (wrappedWindows[window]?.get() != null) {
+        return
+      }
     }
+
+    val delegate = window.callback
+    val wrapper = SentryReplayGestureRecorder(options, touchRecorderCallback, delegate)
+    window.callback = wrapper
+    wrappedWindowsLock.acquire().use { wrappedWindows[window] = WeakReference(wrapper) }
   }
 
   private fun View.stopGestureTracking() {
@@ -60,14 +72,25 @@ internal class GestureRecorder(
 
     val callback = window.callback
     if (callback is SentryReplayGestureRecorder) {
-      val delegate = callback.delegate
-      window.callback = delegate
+      window.callback = callback.delegate
+      wrappedWindowsLock.acquire().use { wrappedWindows.remove(window) }
+      return
+    }
+
+    // Another wrapper (e.g. UserInteractionIntegration) sits on top of ours — cutting it out of
+    // the chain would break its instrumentation, so we inert our buried wrapper instead. The
+    // next replay session will then wrap on top with a fresh active instance.
+    val ours: SentryReplayGestureRecorder?
+    wrappedWindowsLock.acquire().use {
+      ours = wrappedWindows[window]?.get()
+      wrappedWindows.remove(window)
     }
+    ours?.inert()
   }
 
   internal class SentryReplayGestureRecorder(
     private val options: SentryOptions,
-    private val touchRecorderCallback: TouchRecorderCallback?,
+    @Volatile private var touchRecorderCallback: TouchRecorderCallback?,
     delegate: Window.Callback?,
   ) : FixedWindowCallback(delegate) {
     override fun dispatchTouchEvent(event: MotionEvent?): Boolean {
@@ -83,6 +106,14 @@ internal class GestureRecorder(
       }
       return super.dispatchTouchEvent(event)
     }
+
+    /**
+     * Turns this wrapper into a passthrough when it can't be removed from the chain (another
+     * wrapper sits on top). Subsequent dispatches only delegate, skipping the recorder callback.
+     */
+    fun inert() {
+      touchRecorderCallback = null
+    }
   }
 }
 
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/gestures/GestureRecorderTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/gestures/GestureRecorderTest.kt
index bf3f9cb8443..6f5a02b54c7 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/gestures/GestureRecorderTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/gestures/GestureRecorderTest.kt
@@ -5,6 +5,7 @@ import android.app.Activity
 import android.os.Bundle
 import android.view.MotionEvent
 import android.view.View
+import android.view.Window
 import android.widget.LinearLayout
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.SentryOptions
@@ -14,6 +15,7 @@ import io.sentry.android.replay.phoneWindow
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertSame
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.robolectric.Robolectric
@@ -37,17 +39,44 @@ class GestureRecorderTest {
   }
 
   @Test
-  fun `when new window added and window callback is already wrapped, does not wrap it again`() {
+  fun `does not double-wrap when root is added twice and another callback wraps on top`() {
     val activity = Robolectric.buildActivity(TestActivity::class.java).setup().get()
     val gestureRecorder = fixture.getSut()
 
-    activity.root.phoneWindow?.callback = SentryReplayGestureRecorder(fixture.options, null, null)
     gestureRecorder.onRootViewsChanged(activity.root, true)
+    val ourWrapper = activity.root.phoneWindow?.callback as SentryReplayGestureRecorder
 
-    assertFalse(
-      (activity.root.phoneWindow?.callback as SentryReplayGestureRecorder).delegate
-        is SentryReplayGestureRecorder
-    )
+    val outer = WrapperCallback(ourWrapper)
+    activity.root.phoneWindow?.callback = outer
+
+    gestureRecorder.onRootViewsChanged(activity.root, true)
+
+    assertSame(outer, activity.root.phoneWindow?.callback)
+  }
+
+  @Test
+  fun `when stopped with another wrapper on top, inerts the buried recorder`() {
+    var called = false
+    val activity = Robolectric.buildActivity(TestActivity::class.java).setup().get()
+    val gestureRecorder =
+      fixture.getSut(
+        touchRecorderCallback =
+          object : TouchRecorderCallback {
+            override fun onTouchEvent(event: MotionEvent) {
+              called = true
+            }
+          }
+      )
+
+    gestureRecorder.onRootViewsChanged(activity.root, true)
+    val ourWrapper = activity.root.phoneWindow?.callback as SentryReplayGestureRecorder
+    activity.root.phoneWindow?.callback = WrapperCallback(ourWrapper)
+
+    gestureRecorder.onRootViewsChanged(activity.root, false)
+
+    val motionEvent = MotionEvent.obtain(0, 0, MotionEvent.ACTION_DOWN, 0f, 0f, 0)
+    ourWrapper.dispatchTouchEvent(motionEvent)
+    assertFalse(called)
   }
 
   @Test
@@ -109,6 +138,9 @@ class GestureRecorderTest {
   }
 }
 
+private open class WrapperCallback(@JvmField val delegate: Window.Callback) :
+  Window.Callback by delegate
+
 private class TestActivity : Activity() {
   lateinit var root: View
 

From 2fcda643c58bb758682531d41331b5d6f18ba610 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 22 Apr 2026 16:14:16 +0200
Subject: [PATCH 117/391] fix(gestures): Thread-safe SentryGestureDetector with
 per-gesture VelocityTracker recycle (#5301)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(gestures): Recycle VelocityTracker per gesture and guard state with a lock

Recycle VelocityTracker on every ACTION_UP/ACTION_CANCEL instead of only when the detector is torn down, so the pooled native tracker isn't held across gestures (matches Android's framework GestureDetector behavior). Merges endGesture() and release() into a single recycle() method.

Guard onTouchEvent and recycle with an AutoClosableReentrantLock — SentryWindowCallback.stopTracking() can be invoked from a bg thread via Sentry.close(), which would otherwise race with the UI thread's touch dispatch and cause use-after-recycle on the native MotionEvent/VelocityTracker pools. recycle() captures the native handles under the lock and performs the JNI recycle() calls outside it to keep the bg thread's critical section to a pointer swap.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   3 +-
 .../gestures/SentryGestureDetector.java       | 173 +++++++++---------
 .../gestures/SentryWindowCallback.java        |   2 +-
 .../gestures/SentryGestureDetectorTest.kt     |  28 +++
 4 files changed, 119 insertions(+), 87 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f71dedaba95..9ae294f72e1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,8 @@
 
 - Fix `NoSuchMethodError` for `LayoutCoordinates.localBoundingBoxOf$default` on Compose touch dispatch with AGP 8.13 and `minSdk < 24` ([#5302](https://github.com/getsentry/sentry-java/pull/5302))
 - Fix reporting OkHttp's synthetic 504 "Unsatisfiable Request" responses as errors for `CacheControl.FORCE_CACHE` cache misses ([#5299](https://github.com/getsentry/sentry-java/pull/5299))
+- Make `SentryGestureDetector` thread-safe and recycle `VelocityTracker` per gesture ([#5301](https://github.com/getsentry/sentry-java/pull/5301))
+- Fix duplicate `ui.click` breadcrumbs when another `Window.Callback` wraps `SentryWindowCallback` ([#5300](https://github.com/getsentry/sentry-java/pull/5300))
 
 ### Dependencies
 
@@ -27,7 +29,6 @@
 ### Fixes
 
 - Fix ANR caused by `GestureDetectorCompat` Handler/MessageQueue lock contention in `SentryWindowCallback` ([#5138](https://github.com/getsentry/sentry-java/pull/5138))
-- Fix duplicate `ui.click` breadcrumbs when another `Window.Callback` wraps `SentryWindowCallback` ([#5300](https://github.com/getsentry/sentry-java/pull/5300))
 
 ### Internal
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureDetector.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureDetector.java
index 3196ae0189e..002938e9d60 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureDetector.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureDetector.java
@@ -5,6 +5,8 @@
 import android.view.MotionEvent;
 import android.view.VelocityTracker;
 import android.view.ViewConfiguration;
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.util.AutoClosableReentrantLock;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -35,6 +37,8 @@ public final class SentryGestureDetector {
   private @Nullable MotionEvent currentDownEvent;
   private @Nullable VelocityTracker velocityTracker;
 
+  private final @NotNull AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
+
   SentryGestureDetector(
       final @NotNull Context context, final @NotNull GestureDetector.OnGestureListener listener) {
     this.listener = listener;
@@ -46,102 +50,101 @@ public final class SentryGestureDetector {
   }
 
   void onTouchEvent(final @NotNull MotionEvent event) {
-    final int action = event.getActionMasked();
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      final int action = event.getActionMasked();
+
+      if (velocityTracker == null) {
+        velocityTracker = VelocityTracker.obtain();
+      }
+      velocityTracker.addMovement(event);
+
+      switch (action) {
+        case MotionEvent.ACTION_DOWN:
+          downX = event.getX();
+          downY = event.getY();
+          lastX = downX;
+          lastY = downY;
+          isInTapRegion = true;
+          ignoreUpEvent = false;
+
+          if (currentDownEvent != null) {
+            currentDownEvent.recycle();
+          }
+          currentDownEvent = MotionEvent.obtain(event);
 
-    if (velocityTracker == null) {
-      velocityTracker = VelocityTracker.obtain();
-    }
+          listener.onDown(event);
+          break;
 
-    if (action == MotionEvent.ACTION_DOWN) {
-      velocityTracker.clear();
-    }
-    velocityTracker.addMovement(event);
-
-    switch (action) {
-      case MotionEvent.ACTION_DOWN:
-        downX = event.getX();
-        downY = event.getY();
-        lastX = downX;
-        lastY = downY;
-        isInTapRegion = true;
-        ignoreUpEvent = false;
-
-        if (currentDownEvent != null) {
-          currentDownEvent.recycle();
-        }
-        currentDownEvent = MotionEvent.obtain(event);
-
-        listener.onDown(event);
-        break;
-
-      case MotionEvent.ACTION_MOVE:
-        {
-          final float x = event.getX();
-          final float y = event.getY();
-          final float dx = x - downX;
-          final float dy = y - downY;
-          final float distanceSquare = (dx * dx) + (dy * dy);
-
-          if (distanceSquare > touchSlopSquare) {
-            final float scrollX = lastX - x;
-            final float scrollY = lastY - y;
-            listener.onScroll(currentDownEvent, event, scrollX, scrollY);
-            isInTapRegion = false;
-            lastX = x;
-            lastY = y;
+        case MotionEvent.ACTION_MOVE:
+          {
+            final float x = event.getX();
+            final float y = event.getY();
+            final float dx = x - downX;
+            final float dy = y - downY;
+            final float distanceSquare = (dx * dx) + (dy * dy);
+
+            if (distanceSquare > touchSlopSquare) {
+              final float scrollX = lastX - x;
+              final float scrollY = lastY - y;
+              listener.onScroll(currentDownEvent, event, scrollX, scrollY);
+              isInTapRegion = false;
+              lastX = x;
+              lastY = y;
+            }
+            break;
           }
+
+        case MotionEvent.ACTION_POINTER_DOWN:
+          // A second finger means this is not a single tap (e.g. pinch-to-zoom).
+          // Also suppress the UP handler to avoid spurious fling detection when the
+          // last finger lifts quickly after a pinch — mirrors GestureDetector's
+          // mIgnoreNextUpEvent / cancelTaps() behavior.
+          isInTapRegion = false;
+          ignoreUpEvent = true;
           break;
-        }
-
-      case MotionEvent.ACTION_POINTER_DOWN:
-        // A second finger means this is not a single tap (e.g. pinch-to-zoom).
-        // Also suppress the UP handler to avoid spurious fling detection when the
-        // last finger lifts quickly after a pinch — mirrors GestureDetector's
-        // mIgnoreNextUpEvent / cancelTaps() behavior.
-        isInTapRegion = false;
-        ignoreUpEvent = true;
-        break;
-
-      case MotionEvent.ACTION_UP:
-        if (ignoreUpEvent) {
-          endGesture();
-          break;
-        }
-        if (isInTapRegion) {
-          listener.onSingleTapUp(event);
-        } else {
-          final int pointerId = event.getPointerId(0);
-          velocityTracker.computeCurrentVelocity(1000, maximumFlingVelocity);
-          final float velocityX = velocityTracker.getXVelocity(pointerId);
-          final float velocityY = velocityTracker.getYVelocity(pointerId);
-
-          if (Math.abs(velocityX) > minimumFlingVelocity
-              || Math.abs(velocityY) > minimumFlingVelocity) {
-            listener.onFling(currentDownEvent, event, velocityX, velocityY);
+
+        case MotionEvent.ACTION_UP:
+          if (ignoreUpEvent) {
+            recycle();
+            break;
           }
-        }
-        endGesture();
-        break;
+          if (isInTapRegion) {
+            listener.onSingleTapUp(event);
+          } else {
+            final int pointerId = event.getPointerId(0);
+            velocityTracker.computeCurrentVelocity(1000, maximumFlingVelocity);
+            final float velocityX = velocityTracker.getXVelocity(pointerId);
+            final float velocityY = velocityTracker.getYVelocity(pointerId);
+
+            if (Math.abs(velocityX) > minimumFlingVelocity
+                || Math.abs(velocityY) > minimumFlingVelocity) {
+              listener.onFling(currentDownEvent, event, velocityX, velocityY);
+            }
+          }
+          recycle();
+          break;
 
-      case MotionEvent.ACTION_CANCEL:
-        endGesture();
-        break;
+        case MotionEvent.ACTION_CANCEL:
+          recycle();
+          break;
+      }
     }
   }
 
-  /** Releases native resources. Call when the detector is no longer needed. */
-  void release() {
-    endGesture();
-    if (velocityTracker != null) {
-      velocityTracker.recycle();
+  void recycle() {
+    final @Nullable MotionEvent capturedDownEvent;
+    final @Nullable VelocityTracker capturedVelocityTracker;
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      capturedDownEvent = currentDownEvent;
+      currentDownEvent = null;
+      capturedVelocityTracker = velocityTracker;
       velocityTracker = null;
     }
-  }
-
-  private void endGesture() {
-    if (currentDownEvent != null) {
-      currentDownEvent.recycle();
-      currentDownEvent = null;
+    if (capturedDownEvent != null) {
+      capturedDownEvent.recycle();
+    }
+    if (capturedVelocityTracker != null) {
+      capturedVelocityTracker.recycle();
     }
   }
 }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
index e69756e506a..612eb97946e 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryWindowCallback.java
@@ -81,7 +81,7 @@ private void handleTouchEvent(final @NotNull MotionEvent motionEvent) {
   public void stopTracking() {
     inert = true;
     gestureListener.stopTracing(SpanStatus.CANCELLED);
-    gestureDetector.release();
+    gestureDetector.recycle();
   }
 
   public @NotNull Window.Callback getDelegate() {
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureDetectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureDetectorTest.kt
index be15f9c578b..7967c4a3f0c 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureDetectorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureDetectorTest.kt
@@ -322,6 +322,34 @@ class SentryGestureDetectorTest {
     up2.recycle()
   }
 
+  @Test
+  fun `recycle mid-gesture - subsequent gesture still fires onSingleTapUp`() {
+    val sut = fixture.getSut()
+    val downTime = SystemClock.uptimeMillis()
+
+    // Start a gesture, then simulate stopTracking() racing in mid-gesture.
+    val down1 = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, 100f, 100f, 0)
+    sut.onTouchEvent(down1)
+    sut.recycle()
+
+    verify(fixture.listener).onDown(down1)
+
+    // New gesture after recycle — velocityTracker and currentDownEvent should be re-obtained
+    // lazily and the tap path should work as normal.
+    val downTime2 = SystemClock.uptimeMillis()
+    val down2 = MotionEvent.obtain(downTime2, downTime2, MotionEvent.ACTION_DOWN, 200f, 200f, 0)
+    val up2 = MotionEvent.obtain(downTime2, downTime2 + 50, MotionEvent.ACTION_UP, 200f, 200f, 0)
+
+    sut.onTouchEvent(down2)
+    sut.onTouchEvent(up2)
+
+    verify(fixture.listener).onSingleTapUp(up2)
+
+    down1.recycle()
+    down2.recycle()
+    up2.recycle()
+  }
+
   @Test
   fun `sequential gestures - state resets between tap and scroll`() {
     val sut = fixture.getSut()

From 2f670da8b19d00934e13602998c127e66e2e0874 Mon Sep 17 00:00:00 2001
From: markushi <1411808+markushi@users.noreply.github.com>
Date: Wed, 22 Apr 2026 15:47:33 +0000
Subject: [PATCH 118/391] release: 8.40.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9ae294f72e1..6dabfab7294 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.40.0
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index aee4b497d0e..38ad043eee8 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.39.1
+versionName=8.40.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 6b019b757adad61364e3f2fb04fb10060b4b5f44 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Thu, 23 Apr 2026 14:09:12 +0200
Subject: [PATCH 119/391] chore(deps): bump camerax to 1.4.0 for Android 16KB
 page size compatibility (#5329)

---
 gradle/libs.versions.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 3c62935b805..71f433d176c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -39,7 +39,7 @@ compileSdk = "36"
 minSdk = "21"
 spotless = "7.0.4"
 gummyBears = "0.12.0"
-camerax = "1.3.0"
+camerax = "1.4.0"
 openfeature = "1.18.2"
 
 [plugins]

From b28a5d505430e7102bc539d7b6fe9303ca9dfbc2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 27 Apr 2026 12:08:17 +0200
Subject: [PATCH 120/391] build(deps): bump
 getsentry/craft/.github/workflows/changelog-preview.yml from 2.25.4 to 2.26.2
 (#5335)

Bumps [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) from 2.25.4 to 2.26.2.
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/97d0c4286f32a80d09c8b89366d762fecc3e27b6...3dc647fee3586e57c7c31eb900fdec7cbb44f23f)

---
updated-dependencies:
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.26.2
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/changelog-preview.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index d8ea91d129a..64e68738b2e 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@97d0c4286f32a80d09c8b89366d762fecc3e27b6 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@3dc647fee3586e57c7c31eb900fdec7cbb44f23f # v2
     secrets: inherit

From c3602770e7ca4635530daa547a884c27d6fc84ff Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 27 Apr 2026 10:30:43 +0000
Subject: [PATCH 121/391] chore(deps): update Native SDK to v0.13.8 (#5334)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 8 ++++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6dabfab7294..81b5b7d1686 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+### Dependencies
+
+- Bump Native SDK from v0.13.7 to v0.13.8 ([#5334](https://github.com/getsentry/sentry-java/pull/5334))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0138)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.13.7...0.13.8)
+
 ## 8.40.0
 
 ### Fixes
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 71f433d176c..c04ab824c86 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -151,7 +151,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.7" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.8" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 52feca702cd5b95903209091fb3511d296be7275 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 27 Apr 2026 10:31:50 +0000
Subject: [PATCH 122/391] build(deps): bump getsentry/craft from 2.25.4 to
 2.26.2 (#5336)

Bumps [getsentry/craft](https://github.com/getsentry/craft) from 2.25.4 to 2.26.2.
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/97d0c4286f32a80d09c8b89366d762fecc3e27b6...3dc647fee3586e57c7c31eb900fdec7cbb44f23f)

---
updated-dependencies:
- dependency-name: getsentry/craft
  dependency-version: 2.26.2
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 177e8810a1b..66776935d9e 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@97d0c4286f32a80d09c8b89366d762fecc3e27b6 # v2
+        uses: getsentry/craft@3dc647fee3586e57c7c31eb900fdec7cbb44f23f # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From 61659b6eb9cf705591958eb6e4b1ce03c0a49ce3 Mon Sep 17 00:00:00 2001
From: Antonis Lilis <antonis.lilis@gmail.com>
Date: Thu, 30 Apr 2026 09:49:56 +0200
Subject: [PATCH 123/391] feat(android): Add queryable getFramesDelay API to
 SentryFrameMetricsCollector (#5248)

* feat(android): Add queryable getFramesDelay API to SpanFrameMetricsCollector

Expose a getFramesDelay(startNanos, endNanos) method that allows
external consumers (e.g. React Native SDK) to query frame delay for
arbitrary time ranges without registering a duplicate frame listener.

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../api/sentry-android-core.api               |   6 +
 .../android/core/SentryFramesDelayResult.java |  31 ++++
 .../util/SentryFrameMetricsCollector.java     | 102 ++++++++++++
 .../util/SentryFrameMetricsCollectorTest.kt   | 152 ++++++++++++++++++
 4 files changed, 291 insertions(+)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/SentryFramesDelayResult.java

diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 0d83082548f..8af0182bb45 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -435,6 +435,12 @@ public abstract interface class io/sentry/android/core/SentryAndroidOptions$Befo
 	public abstract fun execute (Lio/sentry/SentryEvent;Lio/sentry/Hint;Z)Z
 }
 
+public final class io/sentry/android/core/SentryFramesDelayResult {
+	public fun <init> (DI)V
+	public fun getDelaySeconds ()D
+	public fun getFramesContributingToDelayCount ()I
+}
+
 public final class io/sentry/android/core/SentryInitProvider {
 	public fun <init> ()V
 	public fun attachInfo (Landroid/content/Context;Landroid/content/pm/ProviderInfo;)V
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryFramesDelayResult.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryFramesDelayResult.java
new file mode 100644
index 00000000000..724d8446ea8
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryFramesDelayResult.java
@@ -0,0 +1,31 @@
+package io.sentry.android.core;
+
+import org.jetbrains.annotations.ApiStatus;
+
+/** Result of querying frame delay for a given time range. */
+@ApiStatus.Internal
+public final class SentryFramesDelayResult {
+
+  private final double delaySeconds;
+  private final int framesContributingToDelayCount;
+
+  public SentryFramesDelayResult(
+      final double delaySeconds, final int framesContributingToDelayCount) {
+    this.delaySeconds = delaySeconds;
+    this.framesContributingToDelayCount = framesContributingToDelayCount;
+  }
+
+  /**
+   * @return the total frame delay in seconds, or -1 if incalculable (e.g. no frame data available)
+   */
+  public double getDelaySeconds() {
+    return delaySeconds;
+  }
+
+  /**
+   * @return the number of frames that contributed to the delay (slow + frozen frames)
+   */
+  public int getFramesContributingToDelayCount() {
+    return framesContributingToDelayCount;
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
index 55342c0e4c0..241ab1e4cca 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
@@ -19,12 +19,15 @@
 import io.sentry.SentryUUID;
 import io.sentry.android.core.BuildInfoProvider;
 import io.sentry.android.core.ContextUtils;
+import io.sentry.android.core.SentryFramesDelayResult;
 import io.sentry.util.Objects;
 import java.lang.ref.WeakReference;
 import java.lang.reflect.Field;
+import java.util.Iterator;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentSkipListSet;
 import java.util.concurrent.CopyOnWriteArraySet;
 import java.util.concurrent.TimeUnit;
 import org.jetbrains.annotations.ApiStatus;
@@ -35,6 +38,8 @@
 public final class SentryFrameMetricsCollector implements Application.ActivityLifecycleCallbacks {
   private static final long oneSecondInNanos = TimeUnit.SECONDS.toNanos(1);
   private static final long frozenFrameThresholdNanos = TimeUnit.MILLISECONDS.toNanos(700);
+  private static final int MAX_FRAMES_COUNT = 3600;
+  private static final long MAX_FRAME_AGE_NANOS = 5L * 60 * 1_000_000_000L; // 5 minutes
 
   private final @NotNull BuildInfoProvider buildInfoProvider;
   private final @NotNull Set<Window> trackedWindows = new CopyOnWriteArraySet<>();
@@ -53,6 +58,10 @@ public final class SentryFrameMetricsCollector implements Application.ActivityLi
   private long lastFrameStartNanos = 0;
   private long lastFrameEndNanos = 0;
 
+  // frame buffer for getFramesDelay queries, sorted by frame end time
+  private final @NotNull ConcurrentSkipListSet<DelayedFrame> delayedFrames =
+      new ConcurrentSkipListSet<>();
+
   @SuppressLint("NewApi")
   public SentryFrameMetricsCollector(
       final @NotNull Context context,
@@ -177,6 +186,16 @@ public SentryFrameMetricsCollector(
               isSlow(cpuDuration, (long) ((float) oneSecondInNanos / (refreshRate - 1.0f)));
           final boolean isFrozen = isSlow && isFrozen(cpuDuration);
 
+          final long frameStartTime = startTime;
+
+          // store frames with delay for getFramesDelay queries
+          if (delayNanos > 0) {
+            pruneOldFrames(lastFrameEndNanos);
+            if (delayedFrames.size() < MAX_FRAMES_COUNT) {
+              delayedFrames.add(new DelayedFrame(frameStartTime, lastFrameEndNanos, delayNanos));
+            }
+          }
+
           for (FrameMetricsCollectorListener l : listenerMap.values()) {
             l.onFrameMetricCollected(
                 startTime,
@@ -354,6 +373,89 @@ public long getLastKnownFrameStartTimeNanos() {
     return -1;
   }
 
+  /**
+   * Queries the frame delay for a given time range.
+   *
+   * <p>This is useful for external consumers (e.g. React Native SDK) that need to query frame delay
+   * for an arbitrary time range without registering their own frame listener.
+   *
+   * @param startSystemNanos start of the time range in {@link System#nanoTime()} units
+   * @param endSystemNanos end of the time range in {@link System#nanoTime()} units
+   * @return a {@link SentryFramesDelayResult} with the delay in seconds and the number of frames
+   *     contributing to delay, or a result with delaySeconds=-1 if incalculable
+   */
+  public @NotNull SentryFramesDelayResult getFramesDelay(
+      final long startSystemNanos, final long endSystemNanos) {
+    if (!isAvailable) {
+      return new SentryFramesDelayResult(-1, 0);
+    }
+
+    if (endSystemNanos <= startSystemNanos) {
+      return new SentryFramesDelayResult(-1, 0);
+    }
+
+    long totalDelayNanos = 0;
+    int delayFrameCount = 0;
+
+    if (!delayedFrames.isEmpty()) {
+      final Iterator<DelayedFrame> iterator =
+          delayedFrames.tailSet(new DelayedFrame(startSystemNanos)).iterator();
+
+      while (iterator.hasNext()) {
+        final @NotNull DelayedFrame frame = iterator.next();
+
+        if (frame.startNanos >= endSystemNanos) {
+          break;
+        }
+
+        // The delay portion of a frame is at the end: [frameEnd - delay, frameEnd]
+        final long delayStart = frame.endNanos - frame.delayNanos;
+        final long delayEnd = frame.endNanos;
+
+        // Intersect the delay interval with the query range
+        final long overlapStart = Math.max(delayStart, startSystemNanos);
+        final long overlapEnd = Math.min(delayEnd, endSystemNanos);
+
+        if (overlapEnd > overlapStart) {
+          totalDelayNanos += (overlapEnd - overlapStart);
+          delayFrameCount++;
+        }
+      }
+    }
+
+    final double delaySeconds = totalDelayNanos / 1e9d;
+    return new SentryFramesDelayResult(delaySeconds, delayFrameCount);
+  }
+
+  private void pruneOldFrames(final long currentNanos) {
+    final long cutoff = currentNanos - MAX_FRAME_AGE_NANOS;
+    delayedFrames.headSet(new DelayedFrame(cutoff)).clear();
+  }
+
+  private static class DelayedFrame implements Comparable<DelayedFrame> {
+    final long startNanos;
+    final long endNanos;
+    final long delayNanos;
+
+    /** Sentinel constructor for set range queries (tailSet/headSet). */
+    DelayedFrame(final long timestampNanos) {
+      this(timestampNanos, timestampNanos, 0);
+    }
+
+    DelayedFrame(final long startNanos, final long endNanos, final long delayNanos) {
+      this.startNanos = startNanos;
+      this.endNanos = endNanos;
+      this.delayNanos = delayNanos;
+    }
+
+    @Override
+    public int compareTo(final @NotNull DelayedFrame o) {
+      int cmp = Long.compare(this.endNanos, o.endNanos);
+      if (cmp != 0) return cmp;
+      return Long.compare(this.startNanos, o.startNanos);
+    }
+  }
+
   @ApiStatus.Internal
   public interface FrameMetricsCollectorListener {
     /**
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt
index b3b018e87b2..02f65665a9e 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt
@@ -577,6 +577,158 @@ class SentryFrameMetricsCollectorTest {
     assertEquals(0, collector.getProperty<Set<Window>>("trackedWindows").size)
   }
 
+  @Test
+  fun `getFramesDelay returns -1 when not available`() {
+    val buildInfo =
+      mock<BuildInfoProvider> { whenever(it.sdkInfoVersion).thenReturn(Build.VERSION_CODES.M) }
+    val collector = fixture.getSut(context, buildInfo)
+
+    val result = collector.getFramesDelay(0, TimeUnit.SECONDS.toNanos(1))
+    assertEquals(-1.0, result.delaySeconds)
+    assertEquals(0, result.framesContributingToDelayCount)
+  }
+
+  @Test
+  fun `getFramesDelay returns -1 for invalid time range`() {
+    val collector = fixture.getSut(context)
+
+    val result = collector.getFramesDelay(2000, 1000)
+    assertEquals(-1.0, result.delaySeconds)
+    assertEquals(0, result.framesContributingToDelayCount)
+  }
+
+  @Test
+  fun `getFramesDelay returns zero delay when no slow frames recorded`() {
+    val buildInfo =
+      mock<BuildInfoProvider> { whenever(it.sdkInfoVersion).thenReturn(Build.VERSION_CODES.O) }
+    val collector = fixture.getSut(context, buildInfo)
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+    val listener =
+      collector.getProperty<Window.OnFrameMetricsAvailableListener>("frameMetricsAvailableListener")
+
+    collector.startCollection(mock())
+
+    // emit a fast frame (21ns cpu time — well under 16ms budget)
+    listener.onFrameMetricsAvailable(createMockWindow(), createMockFrameMetrics(), 0)
+
+    // choreographer is at end of range so no pending delay
+    val choreographer = collector.getProperty<Choreographer>("choreographer")
+    choreographer.injectForField("mLastFrameTimeNanos", TimeUnit.SECONDS.toNanos(1))
+
+    val result = collector.getFramesDelay(0, TimeUnit.SECONDS.toNanos(1))
+    assertEquals(0.0, result.delaySeconds)
+    assertEquals(0, result.framesContributingToDelayCount)
+  }
+
+  @Test
+  fun `getFramesDelay calculates delay from slow frames`() {
+    val buildInfo =
+      mock<BuildInfoProvider> { whenever(it.sdkInfoVersion).thenReturn(Build.VERSION_CODES.O) }
+    val collector = fixture.getSut(context, buildInfo)
+    val listener =
+      collector.getProperty<Window.OnFrameMetricsAvailableListener>("frameMetricsAvailableListener")
+
+    collector.startCollection(mock())
+
+    // emit a slow frame (~100ms extra = ~116ms total, well over 16ms budget)
+    listener.onFrameMetricsAvailable(
+      createMockWindow(),
+      createMockFrameMetrics(extraCpuDurationNanos = TimeUnit.MILLISECONDS.toNanos(100)),
+      0,
+    )
+
+    // emit a frozen frame (~1000ms extra = ~1016ms total, well over 700ms)
+    listener.onFrameMetricsAvailable(
+      createMockWindow(),
+      createMockFrameMetrics(extraCpuDurationNanos = TimeUnit.MILLISECONDS.toNanos(1000)),
+      0,
+    )
+
+    // choreographer is at end of range so no pending delay
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+    val choreographer = collector.getProperty<Choreographer>("choreographer")
+    choreographer.injectForField("mLastFrameTimeNanos", TimeUnit.SECONDS.toNanos(5))
+
+    val result = collector.getFramesDelay(0, TimeUnit.SECONDS.toNanos(5))
+    assertTrue(result.delaySeconds > 0)
+    assertEquals(2, result.framesContributingToDelayCount)
+  }
+
+  @Test
+  fun `getFramesDelay handles partial frame overlap`() {
+    val buildInfo =
+      mock<BuildInfoProvider> { whenever(it.sdkInfoVersion).thenReturn(Build.VERSION_CODES.O) }
+    val collector = fixture.getSut(context, buildInfo)
+    val listener =
+      collector.getProperty<Window.OnFrameMetricsAvailableListener>("frameMetricsAvailableListener")
+
+    collector.startCollection(mock())
+
+    // emit a frozen frame (~1s)
+    listener.onFrameMetricsAvailable(
+      createMockWindow(),
+      createMockFrameMetrics(extraCpuDurationNanos = TimeUnit.SECONDS.toNanos(1)),
+      0,
+    )
+
+    // choreographer is at end of range
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+    val choreographer = collector.getProperty<Choreographer>("choreographer")
+    choreographer.injectForField("mLastFrameTimeNanos", TimeUnit.SECONDS.toNanos(5))
+
+    // The frame's delay interval is roughly [~16ms, ~1000ms].
+    // Query from 500ms so the range clips the delay interval in half.
+    val queryStart = TimeUnit.MILLISECONDS.toNanos(500)
+    val queryEnd = TimeUnit.SECONDS.toNanos(5)
+
+    val fullResult = collector.getFramesDelay(0, queryEnd)
+    val partialResult = collector.getFramesDelay(queryStart, queryEnd)
+
+    // partial overlap should yield less delay than the full range
+    assertTrue(partialResult.delaySeconds > 0)
+    assertTrue(partialResult.delaySeconds < fullResult.delaySeconds)
+    assertEquals(1, partialResult.framesContributingToDelayCount)
+  }
+
+  @Test
+  fun `old frames are automatically pruned`() {
+    val buildInfo =
+      mock<BuildInfoProvider> { whenever(it.sdkInfoVersion).thenReturn(Build.VERSION_CODES.O) }
+    val collector = fixture.getSut(context, buildInfo)
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+    val listener =
+      collector.getProperty<Window.OnFrameMetricsAvailableListener>("frameMetricsAvailableListener")
+    val choreographer = collector.getProperty<Choreographer>("choreographer")
+
+    collector.startCollection(mock())
+
+    val t0 = TimeUnit.MINUTES.toNanos(10) // start at a realistic base time
+
+    // emit a slow frame at t0
+    val frameMetrics1 =
+      createMockFrameMetrics(extraCpuDurationNanos = TimeUnit.MILLISECONDS.toNanos(100))
+    whenever(frameMetrics1.getMetric(FrameMetrics.INTENDED_VSYNC_TIMESTAMP)).thenReturn(t0)
+    listener.onFrameMetricsAvailable(createMockWindow(), frameMetrics1, 0)
+
+    choreographer.injectForField("mLastFrameTimeNanos", t0 + TimeUnit.SECONDS.toNanos(1))
+
+    // verify frame exists
+    val resultBefore = collector.getFramesDelay(t0, t0 + TimeUnit.SECONDS.toNanos(1))
+    assertEquals(1, resultBefore.framesContributingToDelayCount)
+
+    // emit another slow frame >5 minutes later to trigger auto-pruning
+    val t1 = t0 + TimeUnit.MINUTES.toNanos(6)
+    val frameMetrics2 =
+      createMockFrameMetrics(extraCpuDurationNanos = TimeUnit.MILLISECONDS.toNanos(100))
+    whenever(frameMetrics2.getMetric(FrameMetrics.INTENDED_VSYNC_TIMESTAMP)).thenReturn(t1)
+    listener.onFrameMetricsAvailable(createMockWindow(), frameMetrics2, 0)
+
+    // the first frame should have been pruned (>5min old)
+    choreographer.injectForField("mLastFrameTimeNanos", t1 + TimeUnit.SECONDS.toNanos(1))
+    val resultAfter = collector.getFramesDelay(t0, t0 + TimeUnit.SECONDS.toNanos(1))
+    assertEquals(0, resultAfter.framesContributingToDelayCount)
+  }
+
   private fun createMockWindow(refreshRate: Float = 60F): Window {
     val mockWindow = mock<Window>()
     val mockDisplay = mock<Display>()

From 7659fe5e58bc7ea6eca4b32b4e34bff0810578ed Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 30 Apr 2026 13:07:38 +0200
Subject: [PATCH 124/391] ref(feedback): Rename Dialog to Form across feedback
 APIs (#5349)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* ref(feedback): Rename Dialog to Form across feedback APIs

Rename SentryUserFeedbackDialog to SentryUserFeedbackForm as the primary
class. Keep SentryUserFeedbackDialog as a deprecated subclass for backward
compatibility.

Also rename internal APIs to use Form naming consistently:
- IDialogHandler -> IFormHandler
- showDialog -> showForm
- setDialogHandler/getDialogHandler -> setFormHandler/getFormHandler
- AndroidUserFeedbackIDialogHandler -> AndroidUserFeedbackFormHandler

Add deprecated Sentry.showUserFeedbackDialog() overloads that delegate to
the new Sentry.showUserFeedbackForm() methods.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): Preserve binary compatibility for deprecated Builder constructors

Use SentryUserFeedbackDialog.OptionsConfiguration as the parameter type
in the deprecated Builder constructors so old compiled code looking for
the original descriptor still resolves correctly.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Make internal ctor package-private

* Add missing deprecated annotaiton

* Fix api

* docs(changelog): Add deprecation entry for feedback Dialog to Form rename

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs(changelog): Note removal in next major version

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(feedback): Add Sentry.feedback() API

Introduce IFeedbackApi with showForm() and capture() methods,
accessible via Sentry.feedback(). This consolidates all feedback
operations under a single API entry point.

Deprecate Sentry.showUserFeedbackForm(), Sentry.showUserFeedbackDialog(),
Sentry.captureFeedback(), and Sentry.captureUserFeedback() in favor of the
new Sentry.feedback() API. All deprecated methods will be removed in the
next major version.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs(changelog): Update section to Features and remove unpublished API

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref(feedback): Move FeedbackApi to IScopes

Add feedback() method to IScopes, matching the pattern used by
logger() and metrics(). FeedbackApi takes an IScopes reference instead
of using Sentry.getCurrentScopes() statically.

Implemented in Scopes, NoOpScopes, NoOpHub, HubAdapter, HubScopesWrapper,
and ScopesAdapter. Sentry.feedback() now delegates to
getCurrentScopes().feedback().

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref: Rename showForm() to show() on IFeedbackApi

Since the method is already namespaced under feedback(), the extra
"Form" suffix is redundant. This aligns with the convention used by
logger() and metrics().

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore: Deprecate UserFeedback and captureUserFeedback, delete showUserFeedbackForm

Deprecate the old `UserFeedback` class and `captureUserFeedback()`
across IScopes, ISentryClient, and all implementations in favor of
`Sentry.feedback().capture()` with the new `Feedback` type.

Delete `Sentry.showUserFeedbackForm()` (3 overloads) as it was never
published.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore: Deprecate SentryEnvelopeItem.fromUserFeedback()

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore: Deprecate SentryClient.buildEnvelope(UserFeedback)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref: Remove unnecessary SuppressWarnings("deprecation")

Deprecated methods don't need to suppress deprecation warnings for
referencing other deprecated types — the deprecation annotation itself
is sufficient.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix test

* remove redudndant deprecated annotations

* fix test

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   9 +
 .../api/sentry-android-core.api               |  33 +-
 .../core/AndroidOptionsInitializer.java       |   2 +-
 .../core/FeedbackShakeIntegration.java        |   2 +-
 .../android/core/SentryAndroidOptions.java    |   6 +-
 .../core/SentryUserFeedbackButton.java        |   4 +-
 .../core/SentryUserFeedbackDialog.java        | 356 +++-------------
 .../android/core/SentryUserFeedbackForm.java  | 379 ++++++++++++++++++
 .../core/AndroidOptionsInitializerTest.kt     |   6 +-
 .../core/FeedbackShakeIntegrationTest.kt      |   4 +-
 ...gTest.kt => SentryUserFeedbackFormTest.kt} |   8 +-
 .../uitest/android/UserFeedbackUiTest.kt      |  14 +-
 .../compose/SentryUserFeedbackButton.kt       |   2 +-
 sentry/api/sentry.api                         |  36 +-
 .../src/main/java/io/sentry/FeedbackApi.java  |  51 +++
 .../src/main/java/io/sentry/HubAdapter.java   |   5 +
 .../main/java/io/sentry/HubScopesWrapper.java |   5 +
 .../src/main/java/io/sentry/IFeedbackApi.java |  29 ++
 sentry/src/main/java/io/sentry/IScopes.java   |   6 +
 .../main/java/io/sentry/ISentryClient.java    |   3 +
 .../main/java/io/sentry/JsonSerializer.java   |   1 +
 .../main/java/io/sentry/NoOpFeedbackApi.java  |  46 +++
 sentry/src/main/java/io/sentry/NoOpHub.java   |   6 +
 .../src/main/java/io/sentry/NoOpScopes.java   |   6 +
 .../main/java/io/sentry/NoOpSentryClient.java |   1 +
 sentry/src/main/java/io/sentry/Scopes.java    |   8 +
 .../main/java/io/sentry/ScopesAdapter.java    |  12 +-
 sentry/src/main/java/io/sentry/Sentry.java    |  66 ++-
 .../src/main/java/io/sentry/SentryClient.java |   2 +
 .../java/io/sentry/SentryEnvelopeItem.java    |   1 +
 .../java/io/sentry/SentryFeedbackOptions.java |  28 +-
 .../main/java/io/sentry/SentryOptions.java    |   2 +-
 .../src/main/java/io/sentry/UserFeedback.java |   8 +-
 .../src/test/java/io/sentry/HubAdapterTest.kt |   2 +
 .../test/java/io/sentry/ScopesAdapterTest.kt  |   2 +
 .../io/sentry/SentryFeedbackOptionsTest.kt    |   8 +-
 .../test/java/io/sentry/SentryOptionsTest.kt  |   4 +-
 sentry/src/test/java/io/sentry/SentryTest.kt  |  32 +-
 38 files changed, 786 insertions(+), 409 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
 rename sentry-android-core/src/test/java/io/sentry/android/core/{SentryUserFeedbackDialogTest.kt => SentryUserFeedbackFormTest.kt} (94%)
 create mode 100644 sentry/src/main/java/io/sentry/FeedbackApi.java
 create mode 100644 sentry/src/main/java/io/sentry/IFeedbackApi.java
 create mode 100644 sentry/src/main/java/io/sentry/NoOpFeedbackApi.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 81b5b7d1686..4d1a581769c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+### Features
+
+- Add `Sentry.feedback()` API for `show()` and `capture()` ([#5349](https://github.com/getsentry/sentry-java/pull/5349))
+  - `Sentry.showUserFeedbackDialog()` is deprecated in favor of `Sentry.feedback().show()`
+  - `Sentry.captureFeedback()` is deprecated in favor of `Sentry.feedback().capture()`
+  - `Sentry.captureUserFeedback()` and `UserFeedback` are deprecated in favor of `Sentry.feedback().capture()` with the new `Feedback` type
+  - `SentryUserFeedbackDialog` is deprecated in favor of `SentryUserFeedbackForm`
+  - All deprecated APIs will be removed in the next major version
+
 ### Dependencies
 
 - Bump Native SDK from v0.13.7 to v0.13.8 ([#5334](https://github.com/getsentry/sentry-java/pull/5334))
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 8af0182bb45..3d4512fc2b4 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -502,23 +502,44 @@ public class io/sentry/android/core/SentryUserFeedbackButton : android/widget/Bu
 	public fun setOnClickListener (Landroid/view/View$OnClickListener;)V
 }
 
-public final class io/sentry/android/core/SentryUserFeedbackDialog : android/app/AlertDialog {
-	public fun setCancelable (Z)V
-	public fun setOnDismissListener (Landroid/content/DialogInterface$OnDismissListener;)V
-	public fun show ()V
+public final class io/sentry/android/core/SentryUserFeedbackDialog : io/sentry/android/core/SentryUserFeedbackForm {
 }
 
-public class io/sentry/android/core/SentryUserFeedbackDialog$Builder {
+public class io/sentry/android/core/SentryUserFeedbackDialog$Builder : io/sentry/android/core/SentryUserFeedbackForm$Builder {
 	public fun <init> (Landroid/content/Context;)V
 	public fun <init> (Landroid/content/Context;I)V
 	public fun <init> (Landroid/content/Context;ILio/sentry/android/core/SentryUserFeedbackDialog$OptionsConfiguration;)V
 	public fun <init> (Landroid/content/Context;Lio/sentry/android/core/SentryUserFeedbackDialog$OptionsConfiguration;)V
 	public fun associatedEventId (Lio/sentry/protocol/SentryId;)Lio/sentry/android/core/SentryUserFeedbackDialog$Builder;
+	public synthetic fun associatedEventId (Lio/sentry/protocol/SentryId;)Lio/sentry/android/core/SentryUserFeedbackForm$Builder;
 	public fun configurator (Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)Lio/sentry/android/core/SentryUserFeedbackDialog$Builder;
+	public synthetic fun configurator (Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)Lio/sentry/android/core/SentryUserFeedbackForm$Builder;
 	public fun create ()Lio/sentry/android/core/SentryUserFeedbackDialog;
+	public synthetic fun create ()Lio/sentry/android/core/SentryUserFeedbackForm;
+}
+
+public abstract interface class io/sentry/android/core/SentryUserFeedbackDialog$OptionsConfiguration : io/sentry/android/core/SentryUserFeedbackForm$OptionsConfiguration {
+}
+
+public class io/sentry/android/core/SentryUserFeedbackForm : android/app/AlertDialog {
+	protected fun onCreate (Landroid/os/Bundle;)V
+	protected fun onStart ()V
+	public fun setCancelable (Z)V
+	public fun setOnDismissListener (Landroid/content/DialogInterface$OnDismissListener;)V
+	public fun show ()V
+}
+
+public class io/sentry/android/core/SentryUserFeedbackForm$Builder {
+	public fun <init> (Landroid/content/Context;)V
+	public fun <init> (Landroid/content/Context;I)V
+	public fun <init> (Landroid/content/Context;ILio/sentry/android/core/SentryUserFeedbackForm$OptionsConfiguration;)V
+	public fun <init> (Landroid/content/Context;Lio/sentry/android/core/SentryUserFeedbackForm$OptionsConfiguration;)V
+	public fun associatedEventId (Lio/sentry/protocol/SentryId;)Lio/sentry/android/core/SentryUserFeedbackForm$Builder;
+	public fun configurator (Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)Lio/sentry/android/core/SentryUserFeedbackForm$Builder;
+	public fun create ()Lio/sentry/android/core/SentryUserFeedbackForm;
 }
 
-public abstract interface class io/sentry/android/core/SentryUserFeedbackDialog$OptionsConfiguration {
+public abstract interface class io/sentry/android/core/SentryUserFeedbackForm$OptionsConfiguration {
 	public abstract fun configure (Landroid/content/Context;Lio/sentry/SentryFeedbackOptions;)V
 }
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 5f7fad69b5d..5704cf7d7d4 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -441,7 +441,7 @@ static void installDefaultIntegrations(
     }
     options
         .getFeedbackOptions()
-        .setDialogHandler(new SentryAndroidOptions.AndroidUserFeedbackIDialogHandler());
+        .setFormHandler(new SentryAndroidOptions.AndroidUserFeedbackFormHandler());
   }
 
   /**
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
index b845b6ed8c4..fc34f18152f 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
@@ -178,7 +178,7 @@ private void startShakeDetection(final @NotNull Activity activity) {
                               }
                               previousOnFormClose = null;
                             });
-                    new SentryUserFeedbackDialog.Builder(active).create().show();
+                    new SentryUserFeedbackForm.Builder(active).create().show();
                   } catch (Throwable e) {
                     isDialogShowing = false;
                     options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
index 054e43322a2..8fe702aad50 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
@@ -741,9 +741,9 @@ public void setEnableAnrFingerprinting(final boolean enableAnrFingerprinting) {
     this.enableAnrFingerprinting = enableAnrFingerprinting;
   }
 
-  static class AndroidUserFeedbackIDialogHandler implements SentryFeedbackOptions.IDialogHandler {
+  static class AndroidUserFeedbackFormHandler implements SentryFeedbackOptions.IFormHandler {
     @Override
-    public void showDialog(
+    public void showForm(
         final @Nullable SentryId associatedEventId,
         final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
       final @Nullable Activity activity = CurrentActivityHolder.getInstance().getActivity();
@@ -758,7 +758,7 @@ public void showDialog(
         return;
       }
 
-      new SentryUserFeedbackDialog.Builder(activity)
+      new SentryUserFeedbackForm.Builder(activity)
           .associatedEventId(associatedEventId)
           .configurator(configurator)
           .create()
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackButton.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackButton.java
index eedafd8f001..729dfd0b4e7 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackButton.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackButton.java
@@ -104,7 +104,7 @@ private void init(
       }
     }
 
-    // Set the default ClickListener to open the SentryUserFeedbackDialog
+    // Set the default ClickListener to open the SentryUserFeedbackForm
     setOnClickListener(delegate);
   }
 
@@ -113,7 +113,7 @@ public void setOnClickListener(final @Nullable OnClickListener listener) {
     delegate = listener;
     super.setOnClickListener(
         v -> {
-          new SentryUserFeedbackDialog.Builder(getContext()).create().show();
+          new SentryUserFeedbackForm.Builder(getContext()).create().show();
           if (delegate != null) {
             delegate.onClick(v);
           }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackDialog.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackDialog.java
index 542a7027a4f..155464b7b73 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackDialog.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackDialog.java
@@ -1,380 +1,114 @@
 package io.sentry.android.core;
 
-import android.app.AlertDialog;
 import android.content.Context;
-import android.os.Bundle;
-import android.view.View;
-import android.widget.Button;
-import android.widget.EditText;
-import android.widget.ImageView;
-import android.widget.TextView;
-import android.widget.Toast;
-import io.sentry.IScopes;
-import io.sentry.Sentry;
 import io.sentry.SentryFeedbackOptions;
-import io.sentry.SentryIntegrationPackageStorage;
-import io.sentry.SentryLevel;
-import io.sentry.SentryOptions;
-import io.sentry.protocol.Feedback;
 import io.sentry.protocol.SentryId;
-import io.sentry.protocol.User;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-public final class SentryUserFeedbackDialog extends AlertDialog {
-
-  private boolean isCancelable = false;
-  private @Nullable SentryId currentReplayId;
-  private final @Nullable SentryId associatedEventId;
-  private @Nullable OnDismissListener delegate;
-
-  private final @Nullable OptionsConfiguration configuration;
-  private final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator;
+/**
+ * @deprecated Use {@link SentryUserFeedbackForm} instead.
+ */
+@Deprecated
+public final class SentryUserFeedbackDialog extends SentryUserFeedbackForm {
 
   SentryUserFeedbackDialog(
       final @NotNull Context context,
       final int themeResId,
       final @Nullable SentryId associatedEventId,
-      final @Nullable OptionsConfiguration configuration,
+      final @Nullable SentryUserFeedbackForm.OptionsConfiguration configuration,
       final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
-    super(context, themeResId);
-    this.associatedEventId = associatedEventId;
-    this.configuration = configuration;
-    this.configurator = configurator;
-    SentryIntegrationPackageStorage.getInstance().addIntegration("UserFeedbackWidget");
-  }
-
-  @Override
-  public void setCancelable(boolean cancelable) {
-    super.setCancelable(cancelable);
-    isCancelable = cancelable;
-  }
-
-  @Override
-  @SuppressWarnings("deprecation")
-  protected void onCreate(Bundle savedInstanceState) {
-    super.onCreate(savedInstanceState);
-    setContentView(R.layout.sentry_dialog_user_feedback);
-    setCancelable(isCancelable);
-
-    final @NotNull SentryFeedbackOptions feedbackOptions =
-        new SentryFeedbackOptions(Sentry.getCurrentScopes().getOptions().getFeedbackOptions());
-    if (configuration != null) {
-      configuration.configure(getContext(), feedbackOptions);
-    }
-    if (configurator != null) {
-      configurator.configure(feedbackOptions);
-    }
-    final @NotNull TextView lblTitle = findViewById(R.id.sentry_dialog_user_feedback_title);
-    final @NotNull ImageView imgLogo = findViewById(R.id.sentry_dialog_user_feedback_logo);
-    final @NotNull TextView lblName = findViewById(R.id.sentry_dialog_user_feedback_txt_name);
-    final @NotNull EditText edtName = findViewById(R.id.sentry_dialog_user_feedback_edt_name);
-    final @NotNull TextView lblEmail = findViewById(R.id.sentry_dialog_user_feedback_txt_email);
-    final @NotNull EditText edtEmail = findViewById(R.id.sentry_dialog_user_feedback_edt_email);
-    final @NotNull TextView lblMessage =
-        findViewById(R.id.sentry_dialog_user_feedback_txt_description);
-    final @NotNull EditText edtMessage =
-        findViewById(R.id.sentry_dialog_user_feedback_edt_description);
-    final @NotNull Button btnSend = findViewById(R.id.sentry_dialog_user_feedback_btn_send);
-    final @NotNull Button btnCancel = findViewById(R.id.sentry_dialog_user_feedback_btn_cancel);
-
-    if (feedbackOptions.isShowBranding()) {
-      imgLogo.setVisibility(View.VISIBLE);
-    } else {
-      imgLogo.setVisibility(View.GONE);
-    }
-
-    // If name is required, ignore showName flag
-    if (!feedbackOptions.isShowName() && !feedbackOptions.isNameRequired()) {
-      lblName.setVisibility(View.GONE);
-      edtName.setVisibility(View.GONE);
-    } else {
-      lblName.setVisibility(View.VISIBLE);
-      edtName.setVisibility(View.VISIBLE);
-      lblName.setText(feedbackOptions.getNameLabel());
-      edtName.setHint(feedbackOptions.getNamePlaceholder());
-      if (feedbackOptions.isNameRequired()) {
-        lblName.append(feedbackOptions.getIsRequiredLabel());
-      }
-    }
-
-    // If email is required, ignore showEmail flag
-    if (!feedbackOptions.isShowEmail() && !feedbackOptions.isEmailRequired()) {
-      lblEmail.setVisibility(View.GONE);
-      edtEmail.setVisibility(View.GONE);
-    } else {
-      lblEmail.setVisibility(View.VISIBLE);
-      edtEmail.setVisibility(View.VISIBLE);
-      lblEmail.setText(feedbackOptions.getEmailLabel());
-      edtEmail.setHint(feedbackOptions.getEmailPlaceholder());
-      if (feedbackOptions.isEmailRequired()) {
-        lblEmail.append(feedbackOptions.getIsRequiredLabel());
-      }
-    }
-
-    // If Sentry user is set, and useSentryUser is true, populate the name and email
-    if (feedbackOptions.isUseSentryUser()) {
-      final @Nullable User user = Sentry.getCurrentScopes().getScope().getUser();
-      if (user != null) {
-        edtName.setText(user.getUsername());
-        edtEmail.setText(user.getEmail());
-      }
-    }
-
-    lblMessage.setText(feedbackOptions.getMessageLabel());
-    lblMessage.append(feedbackOptions.getIsRequiredLabel());
-    edtMessage.setHint(feedbackOptions.getMessagePlaceholder());
-    lblTitle.setText(feedbackOptions.getFormTitle());
-
-    btnSend.setText(feedbackOptions.getSubmitButtonLabel());
-    btnSend.setOnClickListener(
-        v -> {
-          // Gather fields and trim them
-          final @NotNull String name = edtName.getText().toString().trim();
-          final @NotNull String email = edtEmail.getText().toString().trim();
-          final @NotNull String message = edtMessage.getText().toString().trim();
-
-          // If a required field is missing, shows the error label
-          if (name.isEmpty() && feedbackOptions.isNameRequired()) {
-            edtName.setError(lblName.getText());
-            return;
-          }
-
-          if (email.isEmpty() && feedbackOptions.isEmailRequired()) {
-            edtEmail.setError(lblEmail.getText());
-            return;
-          }
-
-          if (message.isEmpty()) {
-            edtMessage.setError(lblMessage.getText());
-            return;
-          }
-
-          // Create the feedback object
-          final @NotNull Feedback feedback = new Feedback(message);
-          feedback.setName(name);
-          feedback.setContactEmail(email);
-          if (associatedEventId != null) {
-            feedback.setAssociatedEventId(associatedEventId);
-          }
-          if (currentReplayId != null) {
-            feedback.setReplayId(currentReplayId);
-          }
-
-          // Capture the feedback. If the ID is empty, it means that the feedback was not sent
-          final @NotNull SentryId id = Sentry.captureFeedback(feedback);
-          if (!id.equals(SentryId.EMPTY_ID)) {
-            Toast.makeText(
-                    getContext(), feedbackOptions.getSuccessMessageText(), Toast.LENGTH_SHORT)
-                .show();
-            final @Nullable SentryFeedbackOptions.SentryFeedbackCallback onSubmitSuccess =
-                feedbackOptions.getOnSubmitSuccess();
-            if (onSubmitSuccess != null) {
-              onSubmitSuccess.call(feedback);
-            }
-          } else {
-            final @Nullable SentryFeedbackOptions.SentryFeedbackCallback onSubmitError =
-                feedbackOptions.getOnSubmitError();
-            if (onSubmitError != null) {
-              onSubmitError.call(feedback);
-            }
-          }
-          cancel();
-        });
-
-    btnCancel.setText(feedbackOptions.getCancelButtonLabel());
-    btnCancel.setOnClickListener(v -> cancel());
-    setOnDismissListener(delegate);
+    super(context, themeResId, associatedEventId, configuration, configurator);
   }
 
-  @Override
-  public void setOnDismissListener(final @Nullable OnDismissListener listener) {
-    delegate = listener;
-    // If the user set a custom onDismissListener, we ensure it doesn't override the onFormClose
-    final @NotNull SentryOptions options = Sentry.getCurrentScopes().getOptions();
-    final @Nullable Runnable onFormClose = options.getFeedbackOptions().getOnFormClose();
-    if (onFormClose != null) {
-      super.setOnDismissListener(
-          dialog -> {
-            onFormClose.run();
-            currentReplayId = null;
-            if (delegate != null) {
-              delegate.onDismiss(dialog);
-            }
-          });
-    } else {
-      super.setOnDismissListener(delegate);
-    }
-  }
-
-  @Override
-  protected void onStart() {
-    super.onStart();
-    final @NotNull SentryOptions options = Sentry.getCurrentScopes().getOptions();
-    final @NotNull SentryFeedbackOptions feedbackOptions = options.getFeedbackOptions();
-    final @Nullable Runnable onFormOpen = feedbackOptions.getOnFormOpen();
-    if (onFormOpen != null) {
-      onFormOpen.run();
-    }
-    options.getReplayController().captureReplay(false);
-    currentReplayId = options.getReplayController().getReplayId();
-  }
-
-  @Override
-  public void show() {
-    // If Sentry is disabled, don't show the dialog, but log a warning
-    final @NotNull IScopes scopes = Sentry.getCurrentScopes();
-    final @NotNull SentryOptions options = scopes.getOptions();
-    if (!scopes.isEnabled() || !options.isEnabled()) {
-      options
-          .getLogger()
-          .log(SentryLevel.WARNING, "Sentry is disabled. Feedback dialog won't be shown.");
-      return;
-    }
-    // Otherwise, show the dialog
-    super.show();
-  }
-
-  public static class Builder {
-
-    @Nullable OptionsConfiguration configuration;
-    @Nullable SentryFeedbackOptions.OptionsConfigurator configurator;
-    @Nullable SentryId associatedEventId;
-    final @NotNull Context context;
-    final int themeResId;
+  /**
+   * @deprecated Use {@link SentryUserFeedbackForm.Builder} instead.
+   */
+  @Deprecated
+  public static class Builder extends SentryUserFeedbackForm.Builder {
 
     /**
      * Creates a builder for a {@link SentryUserFeedbackDialog} that uses the default alert dialog
      * theme.
      *
-     * <p>The default alert dialog theme is defined by {@link android.R.attr#alertDialogTheme}
-     * within the parent {@code context}'s theme.
-     *
      * @param context the parent context
+     * @deprecated Use {@link SentryUserFeedbackForm.Builder#Builder(Context)} instead.
      */
+    @Deprecated
     public Builder(final @NotNull Context context) {
-      this(context, 0);
+      super(context);
     }
 
     /**
      * Creates a builder for a {@link SentryUserFeedbackDialog} that uses an explicit theme
      * resource.
      *
-     * <p>The specified theme resource ({@code themeResId}) is applied on top of the parent {@code
-     * context}'s theme. It may be specified as a style resource containing a fully-populated theme,
-     * such as {@link android.R.style#Theme_Material_Dialog}, to replace all attributes in the
-     * parent {@code context}'s theme including primary and accent colors.
-     *
-     * <p>To preserve attributes such as primary and accent colors, the {@code themeResId} may
-     * instead be specified as an overlay theme such as {@link
-     * android.R.style#ThemeOverlay_Material_Dialog}. This will override only the window attributes
-     * necessary to style the alert window as a dialog.
-     *
-     * <p>Alternatively, the {@code themeResId} may be specified as {@code 0} to use the parent
-     * {@code context}'s resolved value for {@link android.R.attr#alertDialogTheme}.
-     *
      * @param context the parent context
-     * @param themeResId the resource ID of the theme against which to inflate this dialog, or
-     *     {@code 0} to use the parent {@code context}'s default alert dialog theme
+     * @param themeResId the resource ID of the theme
+     * @deprecated Use {@link SentryUserFeedbackForm.Builder#Builder(Context, int)} instead.
      */
+    @Deprecated
     public Builder(Context context, int themeResId) {
-      this(context, themeResId, null);
+      super(context, themeResId);
     }
 
     /**
-     * Creates a builder for a {@link SentryUserFeedbackDialog} that uses the default alert dialog
-     * theme. The {@code configuration} can be used to configure the feedback options for this
-     * specific dialog.
-     *
-     * <p>The default alert dialog theme is defined by {@link android.R.attr#alertDialogTheme}
-     * within the parent {@code context}'s theme.
+     * Creates a builder for a {@link SentryUserFeedbackDialog} with a configuration.
      *
      * @param context the parent context
-     * @param configuration the configuration for the feedback options, can be {@code null} to use
-     *     the global feedback options.
+     * @param configuration the configuration for the feedback options
+     * @deprecated Use {@link SentryUserFeedbackForm.Builder#Builder(Context,
+     *     SentryUserFeedbackForm.OptionsConfiguration)} instead.
      */
+    @Deprecated
     public Builder(
         final @NotNull Context context, final @Nullable OptionsConfiguration configuration) {
-      this(context, 0, configuration);
+      super(context, configuration);
     }
 
     /**
-     * Creates a builder for a {@link SentryUserFeedbackDialog} that uses an explicit theme
-     * resource. The {@code configuration} can be used to configure the feedback options for this
-     * specific dialog.
-     *
-     * <p>The specified theme resource ({@code themeResId}) is applied on top of the parent {@code
-     * context}'s theme. It may be specified as a style resource containing a fully-populated theme,
-     * such as {@link android.R.style#Theme_Material_Dialog}, to replace all attributes in the
-     * parent {@code context}'s theme including primary and accent colors.
-     *
-     * <p>To preserve attributes such as primary and accent colors, the {@code themeResId} may
-     * instead be specified as an overlay theme such as {@link
-     * android.R.style#ThemeOverlay_Material_Dialog}. This will override only the window attributes
-     * necessary to style the alert window as a dialog.
-     *
-     * <p>Alternatively, the {@code themeResId} may be specified as {@code 0} to use the parent
-     * {@code context}'s resolved value for {@link android.R.attr#alertDialogTheme}.
+     * Creates a builder for a {@link SentryUserFeedbackDialog} with a theme and configuration.
      *
      * @param context the parent context
-     * @param themeResId the resource ID of the theme against which to inflate this dialog, or
-     *     {@code 0} to use the parent {@code context}'s default alert dialog theme
-     * @param configuration the configuration for the feedback options, can be {@code null} to use
-     *     the global feedback options.
+     * @param themeResId the resource ID of the theme
+     * @param configuration the configuration for the feedback options
+     * @deprecated Use {@link SentryUserFeedbackForm.Builder#Builder(Context, int,
+     *     SentryUserFeedbackForm.OptionsConfiguration)} instead.
      */
+    @Deprecated
     public Builder(
         final @NotNull Context context,
         final int themeResId,
         final @Nullable OptionsConfiguration configuration) {
-      this.context = context;
-      this.themeResId = themeResId;
-      this.configuration = configuration;
+      super(context, themeResId, configuration);
     }
 
-    /**
-     * Sets the configuration for the feedback options.
-     *
-     * @param configurator the configuration for the feedback options, can be {@code null} to use
-     *     the global feedback options.
-     */
+    @Deprecated
+    @Override
     public Builder configurator(
         final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
-      this.configurator = configurator;
+      super.configurator(configurator);
       return this;
     }
 
-    /**
-     * Sets the associated event ID for the feedback.
-     *
-     * @param associatedEventId the associated event ID for the feedback, can be {@code null} to
-     *     avoid associating the feedback to an event.
-     */
+    @Deprecated
+    @Override
     public Builder associatedEventId(final @Nullable SentryId associatedEventId) {
-      this.associatedEventId = associatedEventId;
+      super.associatedEventId(associatedEventId);
       return this;
     }
 
-    /**
-     * Builds a new {@link SentryUserFeedbackDialog} with the specified context, theme, and
-     * configuration.
-     *
-     * @return a new instance of {@link SentryUserFeedbackDialog}
-     */
+    @Deprecated
+    @Override
     public SentryUserFeedbackDialog create() {
       return new SentryUserFeedbackDialog(
           context, themeResId, associatedEventId, configuration, configurator);
     }
   }
 
-  /** Configuration callback for feedback options. */
-  public interface OptionsConfiguration {
-
-    /**
-     * configure the feedback options
-     *
-     * @param context the context of the feedback dialog
-     * @param options the feedback options
-     */
-    void configure(final @NotNull Context context, final @NotNull SentryFeedbackOptions options);
-  }
+  /**
+   * @deprecated Use {@link SentryUserFeedbackForm.OptionsConfiguration} instead.
+   */
+  @Deprecated
+  public interface OptionsConfiguration extends SentryUserFeedbackForm.OptionsConfiguration {}
 }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
new file mode 100644
index 00000000000..0babe475491
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
@@ -0,0 +1,379 @@
+package io.sentry.android.core;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.os.Bundle;
+import android.view.View;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+import io.sentry.IScopes;
+import io.sentry.Sentry;
+import io.sentry.SentryFeedbackOptions;
+import io.sentry.SentryIntegrationPackageStorage;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import io.sentry.protocol.Feedback;
+import io.sentry.protocol.SentryId;
+import io.sentry.protocol.User;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public class SentryUserFeedbackForm extends AlertDialog {
+
+  private boolean isCancelable = false;
+  private @Nullable SentryId currentReplayId;
+  private final @Nullable SentryId associatedEventId;
+  private @Nullable OnDismissListener delegate;
+
+  private final @Nullable OptionsConfiguration configuration;
+  private final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator;
+
+  SentryUserFeedbackForm(
+      final @NotNull Context context,
+      final int themeResId,
+      final @Nullable SentryId associatedEventId,
+      final @Nullable OptionsConfiguration configuration,
+      final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
+    super(context, themeResId);
+    this.associatedEventId = associatedEventId;
+    this.configuration = configuration;
+    this.configurator = configurator;
+    SentryIntegrationPackageStorage.getInstance().addIntegration("UserFeedbackWidget");
+  }
+
+  @Override
+  public void setCancelable(boolean cancelable) {
+    super.setCancelable(cancelable);
+    isCancelable = cancelable;
+  }
+
+  @Override
+  @SuppressWarnings("deprecation")
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.sentry_dialog_user_feedback);
+    setCancelable(isCancelable);
+
+    final @NotNull SentryFeedbackOptions feedbackOptions =
+        new SentryFeedbackOptions(Sentry.getCurrentScopes().getOptions().getFeedbackOptions());
+    if (configuration != null) {
+      configuration.configure(getContext(), feedbackOptions);
+    }
+    if (configurator != null) {
+      configurator.configure(feedbackOptions);
+    }
+    final @NotNull TextView lblTitle = findViewById(R.id.sentry_dialog_user_feedback_title);
+    final @NotNull ImageView imgLogo = findViewById(R.id.sentry_dialog_user_feedback_logo);
+    final @NotNull TextView lblName = findViewById(R.id.sentry_dialog_user_feedback_txt_name);
+    final @NotNull EditText edtName = findViewById(R.id.sentry_dialog_user_feedback_edt_name);
+    final @NotNull TextView lblEmail = findViewById(R.id.sentry_dialog_user_feedback_txt_email);
+    final @NotNull EditText edtEmail = findViewById(R.id.sentry_dialog_user_feedback_edt_email);
+    final @NotNull TextView lblMessage =
+        findViewById(R.id.sentry_dialog_user_feedback_txt_description);
+    final @NotNull EditText edtMessage =
+        findViewById(R.id.sentry_dialog_user_feedback_edt_description);
+    final @NotNull Button btnSend = findViewById(R.id.sentry_dialog_user_feedback_btn_send);
+    final @NotNull Button btnCancel = findViewById(R.id.sentry_dialog_user_feedback_btn_cancel);
+
+    if (feedbackOptions.isShowBranding()) {
+      imgLogo.setVisibility(View.VISIBLE);
+    } else {
+      imgLogo.setVisibility(View.GONE);
+    }
+
+    // If name is required, ignore showName flag
+    if (!feedbackOptions.isShowName() && !feedbackOptions.isNameRequired()) {
+      lblName.setVisibility(View.GONE);
+      edtName.setVisibility(View.GONE);
+    } else {
+      lblName.setVisibility(View.VISIBLE);
+      edtName.setVisibility(View.VISIBLE);
+      lblName.setText(feedbackOptions.getNameLabel());
+      edtName.setHint(feedbackOptions.getNamePlaceholder());
+      if (feedbackOptions.isNameRequired()) {
+        lblName.append(feedbackOptions.getIsRequiredLabel());
+      }
+    }
+
+    // If email is required, ignore showEmail flag
+    if (!feedbackOptions.isShowEmail() && !feedbackOptions.isEmailRequired()) {
+      lblEmail.setVisibility(View.GONE);
+      edtEmail.setVisibility(View.GONE);
+    } else {
+      lblEmail.setVisibility(View.VISIBLE);
+      edtEmail.setVisibility(View.VISIBLE);
+      lblEmail.setText(feedbackOptions.getEmailLabel());
+      edtEmail.setHint(feedbackOptions.getEmailPlaceholder());
+      if (feedbackOptions.isEmailRequired()) {
+        lblEmail.append(feedbackOptions.getIsRequiredLabel());
+      }
+    }
+
+    // If Sentry user is set, and useSentryUser is true, populate the name and email
+    if (feedbackOptions.isUseSentryUser()) {
+      final @Nullable User user = Sentry.getCurrentScopes().getScope().getUser();
+      if (user != null) {
+        edtName.setText(user.getUsername());
+        edtEmail.setText(user.getEmail());
+      }
+    }
+
+    lblMessage.setText(feedbackOptions.getMessageLabel());
+    lblMessage.append(feedbackOptions.getIsRequiredLabel());
+    edtMessage.setHint(feedbackOptions.getMessagePlaceholder());
+    lblTitle.setText(feedbackOptions.getFormTitle());
+
+    btnSend.setText(feedbackOptions.getSubmitButtonLabel());
+    btnSend.setOnClickListener(
+        v -> {
+          // Gather fields and trim them
+          final @NotNull String name = edtName.getText().toString().trim();
+          final @NotNull String email = edtEmail.getText().toString().trim();
+          final @NotNull String message = edtMessage.getText().toString().trim();
+
+          // If a required field is missing, shows the error label
+          if (name.isEmpty() && feedbackOptions.isNameRequired()) {
+            edtName.setError(lblName.getText());
+            return;
+          }
+
+          if (email.isEmpty() && feedbackOptions.isEmailRequired()) {
+            edtEmail.setError(lblEmail.getText());
+            return;
+          }
+
+          if (message.isEmpty()) {
+            edtMessage.setError(lblMessage.getText());
+            return;
+          }
+
+          // Create the feedback object
+          final @NotNull Feedback feedback = new Feedback(message);
+          feedback.setName(name);
+          feedback.setContactEmail(email);
+          if (associatedEventId != null) {
+            feedback.setAssociatedEventId(associatedEventId);
+          }
+          if (currentReplayId != null) {
+            feedback.setReplayId(currentReplayId);
+          }
+
+          // Capture the feedback. If the ID is empty, it means that the feedback was not sent
+          final @NotNull SentryId id = Sentry.feedback().capture(feedback);
+          if (!id.equals(SentryId.EMPTY_ID)) {
+            Toast.makeText(
+                    getContext(), feedbackOptions.getSuccessMessageText(), Toast.LENGTH_SHORT)
+                .show();
+            final @Nullable SentryFeedbackOptions.SentryFeedbackCallback onSubmitSuccess =
+                feedbackOptions.getOnSubmitSuccess();
+            if (onSubmitSuccess != null) {
+              onSubmitSuccess.call(feedback);
+            }
+          } else {
+            final @Nullable SentryFeedbackOptions.SentryFeedbackCallback onSubmitError =
+                feedbackOptions.getOnSubmitError();
+            if (onSubmitError != null) {
+              onSubmitError.call(feedback);
+            }
+          }
+          cancel();
+        });
+
+    btnCancel.setText(feedbackOptions.getCancelButtonLabel());
+    btnCancel.setOnClickListener(v -> cancel());
+    setOnDismissListener(delegate);
+  }
+
+  @Override
+  public void setOnDismissListener(final @Nullable OnDismissListener listener) {
+    delegate = listener;
+    // If the user set a custom onDismissListener, we ensure it doesn't override the onFormClose
+    final @NotNull SentryOptions options = Sentry.getCurrentScopes().getOptions();
+    final @Nullable Runnable onFormClose = options.getFeedbackOptions().getOnFormClose();
+    if (onFormClose != null) {
+      super.setOnDismissListener(
+          dialog -> {
+            onFormClose.run();
+            currentReplayId = null;
+            if (delegate != null) {
+              delegate.onDismiss(dialog);
+            }
+          });
+    } else {
+      super.setOnDismissListener(delegate);
+    }
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    final @NotNull SentryOptions options = Sentry.getCurrentScopes().getOptions();
+    final @NotNull SentryFeedbackOptions feedbackOptions = options.getFeedbackOptions();
+    final @Nullable Runnable onFormOpen = feedbackOptions.getOnFormOpen();
+    if (onFormOpen != null) {
+      onFormOpen.run();
+    }
+    options.getReplayController().captureReplay(false);
+    currentReplayId = options.getReplayController().getReplayId();
+  }
+
+  @Override
+  public void show() {
+    // If Sentry is disabled, don't show the dialog, but log a warning
+    final @NotNull IScopes scopes = Sentry.getCurrentScopes();
+    final @NotNull SentryOptions options = scopes.getOptions();
+    if (!scopes.isEnabled() || !options.isEnabled()) {
+      options
+          .getLogger()
+          .log(SentryLevel.WARNING, "Sentry is disabled. Feedback dialog won't be shown.");
+      return;
+    }
+    // Otherwise, show the dialog
+    super.show();
+  }
+
+  public static class Builder {
+
+    @Nullable OptionsConfiguration configuration;
+    @Nullable SentryFeedbackOptions.OptionsConfigurator configurator;
+    @Nullable SentryId associatedEventId;
+    final @NotNull Context context;
+    final int themeResId;
+
+    /**
+     * Creates a builder for a {@link SentryUserFeedbackForm} that uses the default alert dialog
+     * theme.
+     *
+     * <p>The default alert dialog theme is defined by {@link android.R.attr#alertDialogTheme}
+     * within the parent {@code context}'s theme.
+     *
+     * @param context the parent context
+     */
+    public Builder(final @NotNull Context context) {
+      this(context, 0);
+    }
+
+    /**
+     * Creates a builder for a {@link SentryUserFeedbackForm} that uses an explicit theme resource.
+     *
+     * <p>The specified theme resource ({@code themeResId}) is applied on top of the parent {@code
+     * context}'s theme. It may be specified as a style resource containing a fully-populated theme,
+     * such as {@link android.R.style#Theme_Material_Dialog}, to replace all attributes in the
+     * parent {@code context}'s theme including primary and accent colors.
+     *
+     * <p>To preserve attributes such as primary and accent colors, the {@code themeResId} may
+     * instead be specified as an overlay theme such as {@link
+     * android.R.style#ThemeOverlay_Material_Dialog}. This will override only the window attributes
+     * necessary to style the alert window as a dialog.
+     *
+     * <p>Alternatively, the {@code themeResId} may be specified as {@code 0} to use the parent
+     * {@code context}'s resolved value for {@link android.R.attr#alertDialogTheme}.
+     *
+     * @param context the parent context
+     * @param themeResId the resource ID of the theme against which to inflate this dialog, or
+     *     {@code 0} to use the parent {@code context}'s default alert dialog theme
+     */
+    public Builder(Context context, int themeResId) {
+      this(context, themeResId, null);
+    }
+
+    /**
+     * Creates a builder for a {@link SentryUserFeedbackForm} that uses the default alert dialog
+     * theme. The {@code configuration} can be used to configure the feedback options for this
+     * specific dialog.
+     *
+     * <p>The default alert dialog theme is defined by {@link android.R.attr#alertDialogTheme}
+     * within the parent {@code context}'s theme.
+     *
+     * @param context the parent context
+     * @param configuration the configuration for the feedback options, can be {@code null} to use
+     *     the global feedback options.
+     */
+    public Builder(
+        final @NotNull Context context, final @Nullable OptionsConfiguration configuration) {
+      this(context, 0, configuration);
+    }
+
+    /**
+     * Creates a builder for a {@link SentryUserFeedbackForm} that uses an explicit theme resource.
+     * The {@code configuration} can be used to configure the feedback options for this specific
+     * dialog.
+     *
+     * <p>The specified theme resource ({@code themeResId}) is applied on top of the parent {@code
+     * context}'s theme. It may be specified as a style resource containing a fully-populated theme,
+     * such as {@link android.R.style#Theme_Material_Dialog}, to replace all attributes in the
+     * parent {@code context}'s theme including primary and accent colors.
+     *
+     * <p>To preserve attributes such as primary and accent colors, the {@code themeResId} may
+     * instead be specified as an overlay theme such as {@link
+     * android.R.style#ThemeOverlay_Material_Dialog}. This will override only the window attributes
+     * necessary to style the alert window as a dialog.
+     *
+     * <p>Alternatively, the {@code themeResId} may be specified as {@code 0} to use the parent
+     * {@code context}'s resolved value for {@link android.R.attr#alertDialogTheme}.
+     *
+     * @param context the parent context
+     * @param themeResId the resource ID of the theme against which to inflate this dialog, or
+     *     {@code 0} to use the parent {@code context}'s default alert dialog theme
+     * @param configuration the configuration for the feedback options, can be {@code null} to use
+     *     the global feedback options.
+     */
+    public Builder(
+        final @NotNull Context context,
+        final int themeResId,
+        final @Nullable OptionsConfiguration configuration) {
+      this.context = context;
+      this.themeResId = themeResId;
+      this.configuration = configuration;
+    }
+
+    /**
+     * Sets the configuration for the feedback options.
+     *
+     * @param configurator the configuration for the feedback options, can be {@code null} to use
+     *     the global feedback options.
+     */
+    public Builder configurator(
+        final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
+      this.configurator = configurator;
+      return this;
+    }
+
+    /**
+     * Sets the associated event ID for the feedback.
+     *
+     * @param associatedEventId the associated event ID for the feedback, can be {@code null} to
+     *     avoid associating the feedback to an event.
+     */
+    public Builder associatedEventId(final @Nullable SentryId associatedEventId) {
+      this.associatedEventId = associatedEventId;
+      return this;
+    }
+
+    /**
+     * Builds a new {@link SentryUserFeedbackForm} with the specified context, theme, and
+     * configuration.
+     *
+     * @return a new instance of {@link SentryUserFeedbackForm}
+     */
+    public SentryUserFeedbackForm create() {
+      return new SentryUserFeedbackForm(
+          context, themeResId, associatedEventId, configuration, configurator);
+    }
+  }
+
+  /** Configuration callback for feedback options. */
+  public interface OptionsConfiguration {
+
+    /**
+     * configure the feedback options
+     *
+     * @param context the context of the feedback dialog
+     * @param options the feedback options
+     */
+    void configure(final @NotNull Context context, final @NotNull SentryFeedbackOptions options);
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
index be54bf7768b..f8724d286f8 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
@@ -18,7 +18,7 @@ import io.sentry.MainEventProcessor
 import io.sentry.NoOpContinuousProfiler
 import io.sentry.NoOpTransactionProfiler
 import io.sentry.SentryOptions
-import io.sentry.android.core.SentryAndroidOptions.AndroidUserFeedbackIDialogHandler
+import io.sentry.android.core.SentryAndroidOptions.AndroidUserFeedbackFormHandler
 import io.sentry.android.core.cache.AndroidEnvelopeCache
 import io.sentry.android.core.internal.debugmeta.AssetsDebugMetaLoader
 import io.sentry.android.core.internal.gestures.AndroidViewGestureTargetLocator
@@ -882,9 +882,9 @@ class AndroidOptionsInitializerTest {
   }
 
   @Test
-  fun `AndroidUserFeedbackIDialogHandler is set as feedback dialog handler`() {
+  fun `AndroidUserFeedbackFormHandler is set as feedback form handler`() {
     fixture.initSut()
-    assertIs<AndroidUserFeedbackIDialogHandler>(fixture.sentryOptions.feedbackOptions.dialogHandler)
+    assertIs<AndroidUserFeedbackFormHandler>(fixture.sentryOptions.feedbackOptions.formHandler)
   }
 
   @Test
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
index cb940686c30..bddc9395c0d 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
@@ -22,10 +22,10 @@ class FeedbackShakeIntegrationTest {
     val scopes = mock<Scopes>()
     val options = SentryAndroidOptions().apply { dsn = "https://key@sentry.io/proj" }
     val activity = mock<Activity>()
-    val dialogHandler = mock<SentryFeedbackOptions.IDialogHandler>()
+    val formHandler = mock<SentryFeedbackOptions.IFormHandler>()
 
     init {
-      options.feedbackOptions.setDialogHandler(dialogHandler)
+      options.feedbackOptions.setFormHandler(formHandler)
     }
 
     fun getSut(useShakeGesture: Boolean = true): FeedbackShakeIntegration {
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackDialogTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt
similarity index 94%
rename from sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackDialogTest.kt
rename to sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt
index bd60859c608..04f6a35716b 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackDialogTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt
@@ -26,7 +26,7 @@ import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.whenever
 
 @RunWith(AndroidJUnit4::class)
-class SentryUserFeedbackDialogTest {
+class SentryUserFeedbackFormTest {
   class Fixture {
     val application: Context = ApplicationProvider.getApplicationContext()
     private val mockDsn = "http://key@localhost/proj"
@@ -55,10 +55,10 @@ class SentryUserFeedbackDialogTest {
 
     fun getSut(
       associatedEventId: SentryId? = null,
-      configuration: SentryUserFeedbackDialog.OptionsConfiguration? = null,
+      configuration: SentryUserFeedbackForm.OptionsConfiguration? = null,
       configurator: SentryFeedbackOptions.OptionsConfigurator? = null,
-    ): SentryUserFeedbackDialog =
-      SentryUserFeedbackDialog(application, 0, associatedEventId, configuration, configurator)
+    ): SentryUserFeedbackForm =
+      SentryUserFeedbackForm(application, 0, associatedEventId, configuration, configurator)
   }
 
   private val fixture = Fixture()
diff --git a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/UserFeedbackUiTest.kt b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/UserFeedbackUiTest.kt
index 39dfae40203..bfcaf2845b3 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/UserFeedbackUiTest.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/UserFeedbackUiTest.kt
@@ -28,7 +28,7 @@ import io.sentry.SentryOptions
 import io.sentry.android.core.AndroidLogger
 import io.sentry.android.core.R
 import io.sentry.android.core.SentryUserFeedbackButton
-import io.sentry.android.core.SentryUserFeedbackDialog
+import io.sentry.android.core.SentryUserFeedbackForm
 import io.sentry.assertEnvelopeFeedback
 import io.sentry.protocol.SentryId
 import io.sentry.protocol.User
@@ -49,21 +49,21 @@ class UserFeedbackUiTest : BaseUiTest() {
   @Test
   fun userFeedbackNotShownWhenSdkDisabled() {
     launchActivity<EmptyActivity>().onActivity {
-      SentryUserFeedbackDialog.Builder(it).create().show()
+      SentryUserFeedbackForm.Builder(it).create().show()
     }
     onView(withId(R.id.sentry_dialog_user_feedback_layout)).check(doesNotExist())
   }
 
   @Test
   fun userFeedbackNotShownWhenSdkDisabledViaApi() {
-    launchActivity<EmptyActivity>().onActivity { Sentry.showUserFeedbackDialog() }
+    launchActivity<EmptyActivity>().onActivity { Sentry.feedback().show() }
     onView(withId(R.id.sentry_dialog_user_feedback_layout)).check(doesNotExist())
   }
 
   @Test
   fun userFeedbackShownViaApi() {
     initSentry()
-    launchActivity<EmptyActivity>().onActivity { Sentry.showUserFeedbackDialog() }
+    launchActivity<EmptyActivity>().onActivity { Sentry.feedback().show() }
 
     onView(withId(R.id.sentry_dialog_user_feedback_layout))
       .inRoot(isDialog())
@@ -639,12 +639,12 @@ class UserFeedbackUiTest : BaseUiTest() {
 
   private fun showDialogAndCheck(
     associatedEventId: SentryId? = null,
-    checker: (dialog: SentryUserFeedbackDialog) -> Unit = {},
+    checker: (dialog: SentryUserFeedbackForm) -> Unit = {},
   ) {
-    lateinit var dialog: SentryUserFeedbackDialog
+    lateinit var dialog: SentryUserFeedbackForm
     val feedbackScenario = launchActivity<EmptyActivity>()
     feedbackScenario.onActivity {
-      dialog = SentryUserFeedbackDialog.Builder(it).associatedEventId(associatedEventId).create()
+      dialog = SentryUserFeedbackForm.Builder(it).associatedEventId(associatedEventId).create()
       dialog.show()
     }
 
diff --git a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryUserFeedbackButton.kt b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryUserFeedbackButton.kt
index 93460b88893..0836c826d32 100644
--- a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryUserFeedbackButton.kt
+++ b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryUserFeedbackButton.kt
@@ -21,7 +21,7 @@ public fun SentryUserFeedbackButton(
   text: String = "Report a Bug",
   configurator: SentryFeedbackOptions.OptionsConfigurator? = null,
 ) {
-  Button(modifier = modifier, onClick = { Sentry.showUserFeedbackDialog(configurator) }) {
+  Button(modifier = modifier, onClick = { Sentry.feedback().show(configurator) }) {
     Row(
       verticalAlignment = Alignment.CenterVertically,
       horizontalArrangement = Arrangement.Center,
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index b9cbb2ae1b2..8bd1e90e094 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -664,6 +664,7 @@ public final class io/sentry/HubAdapter : io/sentry/IHub {
 	public fun configureScope (Lio/sentry/ScopeType;Lio/sentry/ScopeCallback;)V
 	public fun continueTrace (Ljava/lang/String;Ljava/util/List;)Lio/sentry/TransactionContext;
 	public fun endSession ()V
+	public fun feedback ()Lio/sentry/IFeedbackApi;
 	public fun flush (J)V
 	public fun forkedCurrentScope (Ljava/lang/String;)Lio/sentry/IScopes;
 	public fun forkedRootScopes (Ljava/lang/String;)Lio/sentry/IScopes;
@@ -740,6 +741,7 @@ public final class io/sentry/HubScopesWrapper : io/sentry/IHub {
 	public fun configureScope (Lio/sentry/ScopeType;Lio/sentry/ScopeCallback;)V
 	public fun continueTrace (Ljava/lang/String;Ljava/util/List;)Lio/sentry/TransactionContext;
 	public fun endSession ()V
+	public fun feedback ()Lio/sentry/IFeedbackApi;
 	public fun flush (J)V
 	public fun forkedCurrentScope (Ljava/lang/String;)Lio/sentry/IScopes;
 	public fun forkedRootScopes (Ljava/lang/String;)Lio/sentry/IScopes;
@@ -834,6 +836,15 @@ public abstract interface class io/sentry/IEnvelopeSender {
 	public abstract fun processEnvelopeFile (Ljava/lang/String;Lio/sentry/Hint;)V
 }
 
+public abstract interface class io/sentry/IFeedbackApi {
+	public abstract fun capture (Lio/sentry/protocol/Feedback;)Lio/sentry/protocol/SentryId;
+	public abstract fun capture (Lio/sentry/protocol/Feedback;Lio/sentry/Hint;)Lio/sentry/protocol/SentryId;
+	public abstract fun capture (Lio/sentry/protocol/Feedback;Lio/sentry/Hint;Lio/sentry/ScopeCallback;)Lio/sentry/protocol/SentryId;
+	public abstract fun show ()V
+	public abstract fun show (Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
+	public abstract fun show (Lio/sentry/protocol/SentryId;Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
+}
+
 public abstract interface class io/sentry/IHub : io/sentry/IScopes {
 }
 
@@ -1012,6 +1023,7 @@ public abstract interface class io/sentry/IScopes {
 	public abstract fun configureScope (Lio/sentry/ScopeType;Lio/sentry/ScopeCallback;)V
 	public abstract fun continueTrace (Ljava/lang/String;Ljava/util/List;)Lio/sentry/TransactionContext;
 	public abstract fun endSession ()V
+	public abstract fun feedback ()Lio/sentry/IFeedbackApi;
 	public abstract fun flush (J)V
 	public abstract fun forkedCurrentScope (Ljava/lang/String;)Lio/sentry/IScopes;
 	public abstract fun forkedRootScopes (Ljava/lang/String;)Lio/sentry/IScopes;
@@ -1569,6 +1581,16 @@ public final class io/sentry/NoOpEnvelopeReader : io/sentry/IEnvelopeReader {
 	public fun read (Ljava/io/InputStream;)Lio/sentry/SentryEnvelope;
 }
 
+public final class io/sentry/NoOpFeedbackApi : io/sentry/IFeedbackApi {
+	public fun capture (Lio/sentry/protocol/Feedback;)Lio/sentry/protocol/SentryId;
+	public fun capture (Lio/sentry/protocol/Feedback;Lio/sentry/Hint;)Lio/sentry/protocol/SentryId;
+	public fun capture (Lio/sentry/protocol/Feedback;Lio/sentry/Hint;Lio/sentry/ScopeCallback;)Lio/sentry/protocol/SentryId;
+	public static fun getInstance ()Lio/sentry/NoOpFeedbackApi;
+	public fun show ()V
+	public fun show (Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
+	public fun show (Lio/sentry/protocol/SentryId;Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
+}
+
 public final class io/sentry/NoOpHub : io/sentry/IHub {
 	public fun addBreadcrumb (Lio/sentry/Breadcrumb;)V
 	public fun addBreadcrumb (Lio/sentry/Breadcrumb;Lio/sentry/Hint;)V
@@ -1595,6 +1617,7 @@ public final class io/sentry/NoOpHub : io/sentry/IHub {
 	public fun configureScope (Lio/sentry/ScopeType;Lio/sentry/ScopeCallback;)V
 	public fun continueTrace (Ljava/lang/String;Ljava/util/List;)Lio/sentry/TransactionContext;
 	public fun endSession ()V
+	public fun feedback ()Lio/sentry/IFeedbackApi;
 	public fun flush (J)V
 	public fun forkedCurrentScope (Ljava/lang/String;)Lio/sentry/IScopes;
 	public fun forkedRootScopes (Ljava/lang/String;)Lio/sentry/IScopes;
@@ -1781,6 +1804,7 @@ public final class io/sentry/NoOpScopes : io/sentry/IScopes {
 	public fun configureScope (Lio/sentry/ScopeType;Lio/sentry/ScopeCallback;)V
 	public fun continueTrace (Ljava/lang/String;Ljava/util/List;)Lio/sentry/TransactionContext;
 	public fun endSession ()V
+	public fun feedback ()Lio/sentry/IFeedbackApi;
 	public fun flush (J)V
 	public fun forkedCurrentScope (Ljava/lang/String;)Lio/sentry/IScopes;
 	public fun forkedRootScopes (Ljava/lang/String;)Lio/sentry/IScopes;
@@ -2517,6 +2541,7 @@ public final class io/sentry/Scopes : io/sentry/IScopes {
 	public fun configureScope (Lio/sentry/ScopeType;Lio/sentry/ScopeCallback;)V
 	public fun continueTrace (Ljava/lang/String;Ljava/util/List;)Lio/sentry/TransactionContext;
 	public fun endSession ()V
+	public fun feedback ()Lio/sentry/IFeedbackApi;
 	public fun flush (J)V
 	public fun forkedCurrentScope (Ljava/lang/String;)Lio/sentry/IScopes;
 	public fun forkedRootScopes (Ljava/lang/String;)Lio/sentry/IScopes;
@@ -2596,6 +2621,7 @@ public final class io/sentry/ScopesAdapter : io/sentry/IScopes {
 	public fun configureScope (Lio/sentry/ScopeType;Lio/sentry/ScopeCallback;)V
 	public fun continueTrace (Ljava/lang/String;Ljava/util/List;)Lio/sentry/TransactionContext;
 	public fun endSession ()V
+	public fun feedback ()Lio/sentry/IFeedbackApi;
 	public fun flush (J)V
 	public fun forkedCurrentScope (Ljava/lang/String;)Lio/sentry/IScopes;
 	public fun forkedRootScopes (Ljava/lang/String;)Lio/sentry/IScopes;
@@ -2720,6 +2746,7 @@ public final class io/sentry/Sentry {
 	public static fun continueTrace (Ljava/lang/String;Ljava/util/List;)Lio/sentry/TransactionContext;
 	public static fun distribution ()Lio/sentry/IDistributionApi;
 	public static fun endSession ()V
+	public static fun feedback ()Lio/sentry/IFeedbackApi;
 	public static fun flush (J)V
 	public static fun forkedCurrentScope (Ljava/lang/String;)Lio/sentry/IScopes;
 	public static fun forkedRootScopes (Ljava/lang/String;)Lio/sentry/IScopes;
@@ -3151,12 +3178,11 @@ public final class io/sentry/SentryExecutorService : io/sentry/ISentryExecutorSe
 }
 
 public final class io/sentry/SentryFeedbackOptions {
-	public fun <init> (Lio/sentry/SentryFeedbackOptions$IDialogHandler;)V
 	public fun <init> (Lio/sentry/SentryFeedbackOptions;)V
 	public fun getCancelButtonLabel ()Ljava/lang/CharSequence;
-	public fun getDialogHandler ()Lio/sentry/SentryFeedbackOptions$IDialogHandler;
 	public fun getEmailLabel ()Ljava/lang/CharSequence;
 	public fun getEmailPlaceholder ()Ljava/lang/CharSequence;
+	public fun getFormHandler ()Lio/sentry/SentryFeedbackOptions$IFormHandler;
 	public fun getFormTitle ()Ljava/lang/CharSequence;
 	public fun getIsRequiredLabel ()Ljava/lang/CharSequence;
 	public fun getMessageLabel ()Ljava/lang/CharSequence;
@@ -3177,10 +3203,10 @@ public final class io/sentry/SentryFeedbackOptions {
 	public fun isUseSentryUser ()Z
 	public fun isUseShakeGesture ()Z
 	public fun setCancelButtonLabel (Ljava/lang/CharSequence;)V
-	public fun setDialogHandler (Lio/sentry/SentryFeedbackOptions$IDialogHandler;)V
 	public fun setEmailLabel (Ljava/lang/CharSequence;)V
 	public fun setEmailPlaceholder (Ljava/lang/CharSequence;)V
 	public fun setEmailRequired (Z)V
+	public fun setFormHandler (Lio/sentry/SentryFeedbackOptions$IFormHandler;)V
 	public fun setFormTitle (Ljava/lang/CharSequence;)V
 	public fun setIsRequiredLabel (Ljava/lang/CharSequence;)V
 	public fun setMessageLabel (Ljava/lang/CharSequence;)V
@@ -3202,8 +3228,8 @@ public final class io/sentry/SentryFeedbackOptions {
 	public fun toString ()Ljava/lang/String;
 }
 
-public abstract interface class io/sentry/SentryFeedbackOptions$IDialogHandler {
-	public abstract fun showDialog (Lio/sentry/protocol/SentryId;Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
+public abstract interface class io/sentry/SentryFeedbackOptions$IFormHandler {
+	public abstract fun showForm (Lio/sentry/protocol/SentryId;Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
 }
 
 public abstract interface class io/sentry/SentryFeedbackOptions$OptionsConfigurator {
diff --git a/sentry/src/main/java/io/sentry/FeedbackApi.java b/sentry/src/main/java/io/sentry/FeedbackApi.java
new file mode 100644
index 00000000000..b8b8a3c9b9a
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/FeedbackApi.java
@@ -0,0 +1,51 @@
+package io.sentry;
+
+import io.sentry.protocol.Feedback;
+import io.sentry.protocol.SentryId;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+final class FeedbackApi implements IFeedbackApi {
+
+  private final @NotNull IScopes scopes;
+
+  FeedbackApi(final @NotNull IScopes scopes) {
+    this.scopes = scopes;
+  }
+
+  @Override
+  public void show() {
+    show(null, null);
+  }
+
+  @Override
+  public void show(final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
+    show(null, configurator);
+  }
+
+  @Override
+  public void show(
+      final @Nullable SentryId associatedEventId,
+      final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
+    final @NotNull SentryOptions options = scopes.getOptions();
+    options.getFeedbackOptions().getFormHandler().showForm(associatedEventId, configurator);
+  }
+
+  @Override
+  public @NotNull SentryId capture(final @NotNull Feedback feedback) {
+    return scopes.captureFeedback(feedback);
+  }
+
+  @Override
+  public @NotNull SentryId capture(final @NotNull Feedback feedback, final @Nullable Hint hint) {
+    return scopes.captureFeedback(feedback, hint);
+  }
+
+  @Override
+  public @NotNull SentryId capture(
+      final @NotNull Feedback feedback,
+      final @Nullable Hint hint,
+      final @Nullable ScopeCallback callback) {
+    return scopes.captureFeedback(feedback, hint, callback);
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/HubAdapter.java b/sentry/src/main/java/io/sentry/HubAdapter.java
index cf90eb1fe65..5e2d91a9ae8 100644
--- a/sentry/src/main/java/io/sentry/HubAdapter.java
+++ b/sentry/src/main/java/io/sentry/HubAdapter.java
@@ -395,6 +395,11 @@ public void reportFullyDisplayed() {
     return Sentry.getCurrentScopes().metrics();
   }
 
+  @Override
+  public @NotNull IFeedbackApi feedback() {
+    return Sentry.getCurrentScopes().feedback();
+  }
+
   @Override
   public void setAttribute(final @Nullable String key, final @Nullable Object value) {
     Sentry.setAttribute(key, value);
diff --git a/sentry/src/main/java/io/sentry/HubScopesWrapper.java b/sentry/src/main/java/io/sentry/HubScopesWrapper.java
index 66a34b4dc36..00395292fd5 100644
--- a/sentry/src/main/java/io/sentry/HubScopesWrapper.java
+++ b/sentry/src/main/java/io/sentry/HubScopesWrapper.java
@@ -380,6 +380,11 @@ public void reportFullyDisplayed() {
     return scopes.metrics();
   }
 
+  @Override
+  public @NotNull IFeedbackApi feedback() {
+    return scopes.feedback();
+  }
+
   @Override
   public void setAttribute(final @Nullable String key, final @Nullable Object value) {
     scopes.setAttribute(key, value);
diff --git a/sentry/src/main/java/io/sentry/IFeedbackApi.java b/sentry/src/main/java/io/sentry/IFeedbackApi.java
new file mode 100644
index 00000000000..5bab630fa8b
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/IFeedbackApi.java
@@ -0,0 +1,29 @@
+package io.sentry;
+
+import io.sentry.protocol.Feedback;
+import io.sentry.protocol.SentryId;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface IFeedbackApi {
+
+  void show();
+
+  void show(final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator);
+
+  void show(
+      final @Nullable SentryId associatedEventId,
+      final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator);
+
+  @NotNull
+  SentryId capture(final @NotNull Feedback feedback);
+
+  @NotNull
+  SentryId capture(final @NotNull Feedback feedback, final @Nullable Hint hint);
+
+  @NotNull
+  SentryId capture(
+      final @NotNull Feedback feedback,
+      final @Nullable Hint hint,
+      final @Nullable ScopeCallback callback);
+}
diff --git a/sentry/src/main/java/io/sentry/IScopes.java b/sentry/src/main/java/io/sentry/IScopes.java
index b1b437f72e5..26ea0dcc3ea 100644
--- a/sentry/src/main/java/io/sentry/IScopes.java
+++ b/sentry/src/main/java/io/sentry/IScopes.java
@@ -217,7 +217,10 @@ SentryId captureException(
    * Captures a manually created user feedback and sends it to Sentry.
    *
    * @param userFeedback The user feedback to send to Sentry.
+   * @deprecated Use {@link #feedback()}.{@link IFeedbackApi#capture(io.sentry.protocol.Feedback)
+   *     capture(feedback)} with the new {@link io.sentry.protocol.Feedback} type instead.
    */
+  @Deprecated
   void captureUserFeedback(@NotNull UserFeedback userFeedback);
 
   /** Starts a new session. If there's a running session, it ends it before starting the new one. */
@@ -748,6 +751,9 @@ default boolean isNoOp() {
   @NotNull
   IMetricsApi metrics();
 
+  @NotNull
+  IFeedbackApi feedback();
+
   /**
    * Sets an attribute.
    *
diff --git a/sentry/src/main/java/io/sentry/ISentryClient.java b/sentry/src/main/java/io/sentry/ISentryClient.java
index 98b6034bb78..2a1df15f812 100644
--- a/sentry/src/main/java/io/sentry/ISentryClient.java
+++ b/sentry/src/main/java/io/sentry/ISentryClient.java
@@ -174,7 +174,10 @@ SentryId captureReplayEvent(
    * Captures a manually created user feedback and sends it to Sentry.
    *
    * @param userFeedback The user feedback to send to Sentry.
+   * @deprecated Use {@link IFeedbackApi#capture(io.sentry.protocol.Feedback)} with the new {@link
+   *     io.sentry.protocol.Feedback} type instead.
    */
+  @Deprecated
   void captureUserFeedback(@NotNull UserFeedback userFeedback);
 
   /**
diff --git a/sentry/src/main/java/io/sentry/JsonSerializer.java b/sentry/src/main/java/io/sentry/JsonSerializer.java
index a0fa80879aa..2b24090d0cc 100644
--- a/sentry/src/main/java/io/sentry/JsonSerializer.java
+++ b/sentry/src/main/java/io/sentry/JsonSerializer.java
@@ -72,6 +72,7 @@ public final class JsonSerializer implements ISerializer {
   /**
    * All our custom deserializers need to be registered to be used with the deserializer instance. *
    */
+  @SuppressWarnings("deprecation")
   public JsonSerializer(@NotNull SentryOptions options) {
     this.options = options;
 
diff --git a/sentry/src/main/java/io/sentry/NoOpFeedbackApi.java b/sentry/src/main/java/io/sentry/NoOpFeedbackApi.java
new file mode 100644
index 00000000000..bdef5d37590
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/NoOpFeedbackApi.java
@@ -0,0 +1,46 @@
+package io.sentry;
+
+import io.sentry.protocol.Feedback;
+import io.sentry.protocol.SentryId;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public final class NoOpFeedbackApi implements IFeedbackApi {
+
+  private static final NoOpFeedbackApi instance = new NoOpFeedbackApi();
+
+  private NoOpFeedbackApi() {}
+
+  public static NoOpFeedbackApi getInstance() {
+    return instance;
+  }
+
+  @Override
+  public void show() {}
+
+  @Override
+  public void show(final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {}
+
+  @Override
+  public void show(
+      final @Nullable SentryId associatedEventId,
+      final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {}
+
+  @Override
+  public @NotNull SentryId capture(final @NotNull Feedback feedback) {
+    return SentryId.EMPTY_ID;
+  }
+
+  @Override
+  public @NotNull SentryId capture(final @NotNull Feedback feedback, final @Nullable Hint hint) {
+    return SentryId.EMPTY_ID;
+  }
+
+  @Override
+  public @NotNull SentryId capture(
+      final @NotNull Feedback feedback,
+      final @Nullable Hint hint,
+      final @Nullable ScopeCallback callback) {
+    return SentryId.EMPTY_ID;
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/NoOpHub.java b/sentry/src/main/java/io/sentry/NoOpHub.java
index 4a02be1bd40..d5ef143d342 100644
--- a/sentry/src/main/java/io/sentry/NoOpHub.java
+++ b/sentry/src/main/java/io/sentry/NoOpHub.java
@@ -80,6 +80,7 @@ public boolean isEnabled() {
     return SentryId.EMPTY_ID;
   }
 
+  @Deprecated
   @Override
   public void captureUserFeedback(@NotNull UserFeedback userFeedback) {}
 
@@ -338,6 +339,11 @@ public boolean isNoOp() {
     return NoOpMetricsApi.getInstance();
   }
 
+  @Override
+  public @NotNull IFeedbackApi feedback() {
+    return NoOpFeedbackApi.getInstance();
+  }
+
   @Override
   public void setAttribute(final @Nullable String key, final @Nullable Object value) {}
 
diff --git a/sentry/src/main/java/io/sentry/NoOpScopes.java b/sentry/src/main/java/io/sentry/NoOpScopes.java
index 1ae357d502e..345c74cc0ee 100644
--- a/sentry/src/main/java/io/sentry/NoOpScopes.java
+++ b/sentry/src/main/java/io/sentry/NoOpScopes.java
@@ -77,6 +77,7 @@ public boolean isEnabled() {
     return SentryId.EMPTY_ID;
   }
 
+  @Deprecated
   @Override
   public void captureUserFeedback(@NotNull UserFeedback userFeedback) {}
 
@@ -336,6 +337,11 @@ public boolean isNoOp() {
     return NoOpMetricsApi.getInstance();
   }
 
+  @Override
+  public @NotNull IFeedbackApi feedback() {
+    return NoOpFeedbackApi.getInstance();
+  }
+
   @Override
   public void setAttribute(final @Nullable String key, final @Nullable Object value) {}
 
diff --git a/sentry/src/main/java/io/sentry/NoOpSentryClient.java b/sentry/src/main/java/io/sentry/NoOpSentryClient.java
index 961ef9031be..ac9ff2344bf 100644
--- a/sentry/src/main/java/io/sentry/NoOpSentryClient.java
+++ b/sentry/src/main/java/io/sentry/NoOpSentryClient.java
@@ -44,6 +44,7 @@ public void flush(long timeoutMillis) {}
     return SentryId.EMPTY_ID;
   }
 
+  @Deprecated
   @Override
   public void captureUserFeedback(@NotNull UserFeedback userFeedback) {}
 
diff --git a/sentry/src/main/java/io/sentry/Scopes.java b/sentry/src/main/java/io/sentry/Scopes.java
index 82c03feac4b..3b67b94916e 100644
--- a/sentry/src/main/java/io/sentry/Scopes.java
+++ b/sentry/src/main/java/io/sentry/Scopes.java
@@ -34,6 +34,7 @@ public final class Scopes implements IScopes {
   private final @NotNull CombinedScopeView combinedScope;
   private final @NotNull ILoggerApi logger;
   private final @NotNull IMetricsApi metrics;
+  private final @NotNull IFeedbackApi feedbackApi;
 
   public Scopes(
       final @NotNull IScope scope,
@@ -61,6 +62,7 @@ private Scopes(
     this.compositePerformanceCollector = options.getCompositePerformanceCollector();
     this.logger = new LoggerApi(this);
     this.metrics = new MetricsApi(this);
+    this.feedbackApi = new FeedbackApi(this);
   }
 
   public @NotNull String getCreator() {
@@ -344,6 +346,7 @@ private void assignTraceContext(final @NotNull SentryEvent event) {
     return sentryId;
   }
 
+  @Deprecated
   @Override
   public void captureUserFeedback(final @NotNull UserFeedback userFeedback) {
     if (!isEnabled()) {
@@ -1245,6 +1248,11 @@ public void reportFullyDisplayed() {
     return metrics;
   }
 
+  @Override
+  public @NotNull IFeedbackApi feedback() {
+    return feedbackApi;
+  }
+
   @Override
   public void setAttribute(final @Nullable String key, final @Nullable Object value) {
     if (!isEnabled()) {
diff --git a/sentry/src/main/java/io/sentry/ScopesAdapter.java b/sentry/src/main/java/io/sentry/ScopesAdapter.java
index b66b681a332..b697a950501 100644
--- a/sentry/src/main/java/io/sentry/ScopesAdapter.java
+++ b/sentry/src/main/java/io/sentry/ScopesAdapter.java
@@ -51,18 +51,18 @@ public boolean isEnabled() {
 
   @Override
   public @NotNull SentryId captureFeedback(@NotNull Feedback feedback) {
-    return Sentry.captureFeedback(feedback);
+    return Sentry.feedback().capture(feedback);
   }
 
   @Override
   public @NotNull SentryId captureFeedback(@NotNull Feedback feedback, @Nullable Hint hint) {
-    return Sentry.captureFeedback(feedback, hint);
+    return Sentry.feedback().capture(feedback, hint);
   }
 
   @Override
   public @NotNull SentryId captureFeedback(
       @NotNull Feedback feedback, @Nullable Hint hint, @Nullable ScopeCallback callback) {
-    return Sentry.captureFeedback(feedback, hint, callback);
+    return Sentry.feedback().capture(feedback, hint, callback);
   }
 
   @ApiStatus.Internal
@@ -82,6 +82,7 @@ public boolean isEnabled() {
     return Sentry.captureException(throwable, hint, callback);
   }
 
+  @Deprecated
   @Override
   public void captureUserFeedback(@NotNull UserFeedback userFeedback) {
     Sentry.captureUserFeedback(userFeedback);
@@ -392,6 +393,11 @@ public void reportFullyDisplayed() {
     return Sentry.getCurrentScopes().metrics();
   }
 
+  @Override
+  public @NotNull IFeedbackApi feedback() {
+    return Sentry.getCurrentScopes().feedback();
+  }
+
   @Override
   public void setAttribute(final @Nullable String key, final @Nullable Object value) {
     Sentry.setAttribute(key, value);
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index fee19dc4d09..919607e5879 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -827,40 +827,37 @@ public static void close() {
   }
 
   /**
-   * Captures the feedback.
-   *
-   * @param feedback The feedback to send.
-   * @return The Id (SentryId object) of the event
+   * @deprecated Use {@link #feedback()}.{@link IFeedbackApi#capture(Feedback) capture(feedback)}
+   *     instead.
    */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public static @NotNull SentryId captureFeedback(final @NotNull Feedback feedback) {
-    return getCurrentScopes().captureFeedback(feedback);
+    return feedback().capture(feedback);
   }
 
   /**
-   * Captures the feedback.
-   *
-   * @param feedback The feedback to send.
-   * @param hint An optional hint to be applied to the event.
-   * @return The Id (SentryId object) of the event
+   * @deprecated Use {@link #feedback()}.{@link IFeedbackApi#capture(Feedback, Hint)
+   *     capture(feedback, hint)} instead.
    */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public static @NotNull SentryId captureFeedback(
       final @NotNull Feedback feedback, final @Nullable Hint hint) {
-    return getCurrentScopes().captureFeedback(feedback, hint);
+    return feedback().capture(feedback, hint);
   }
 
   /**
-   * Captures the feedback.
-   *
-   * @param feedback The feedback to send.
-   * @param hint An optional hint to be applied to the event.
-   * @param callback The callback to configure the scope for a single invocation.
-   * @return The Id (SentryId object) of the event
+   * @deprecated Use {@link #feedback()}.{@link IFeedbackApi#capture(Feedback, Hint, ScopeCallback)
+   *     capture(feedback, hint, callback)} instead.
    */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public static @NotNull SentryId captureFeedback(
       final @NotNull Feedback feedback,
       final @Nullable Hint hint,
       final @Nullable ScopeCallback callback) {
-    return getCurrentScopes().captureFeedback(feedback, hint, callback);
+    return feedback().capture(feedback, hint, callback);
   }
 
   /**
@@ -916,7 +913,11 @@ public static void close() {
    * Captures a manually created user feedback and sends it to Sentry.
    *
    * @param userFeedback The user feedback to send to Sentry.
+   * @deprecated Use {@link #feedback()}.{@link IFeedbackApi#capture(Feedback) capture(feedback)}
+   *     with the new {@link Feedback} type instead.
    */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public static void captureUserFeedback(final @NotNull UserFeedback userFeedback) {
     getCurrentScopes().captureUserFeedback(userFeedback);
   }
@@ -1355,20 +1356,41 @@ public static IMetricsApi metrics() {
     return getCurrentScopes().metrics();
   }
 
+  @NotNull
+  public static IFeedbackApi feedback() {
+    return getCurrentScopes().feedback();
+  }
+
+  /**
+   * @deprecated Use {@link #feedback()}.{@link IFeedbackApi#show() show()} instead.
+   */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public static void showUserFeedbackDialog() {
-    showUserFeedbackDialog(null);
+    feedback().show();
   }
 
+  /**
+   * @deprecated Use {@link #feedback()}.{@link
+   *     IFeedbackApi#show(SentryFeedbackOptions.OptionsConfigurator) show(configurator)} instead.
+   */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public static void showUserFeedbackDialog(
       final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
-    showUserFeedbackDialog(null, configurator);
+    feedback().show(configurator);
   }
 
+  /**
+   * @deprecated Use {@link #feedback()}.{@link IFeedbackApi#show(SentryId,
+   *     SentryFeedbackOptions.OptionsConfigurator) show(associatedEventId, configurator)} instead.
+   */
+  @Deprecated
+  @SuppressWarnings("InlineMeSuggester")
   public static void showUserFeedbackDialog(
       final @Nullable SentryId associatedEventId,
       final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
-    final @NotNull SentryOptions options = getCurrentScopes().getOptions();
-    options.getFeedbackOptions().getDialogHandler().showDialog(associatedEventId, configurator);
+    feedback().show(associatedEventId, configurator);
   }
 
   /**
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index b8178e35517..c99fcaeaa2f 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -688,6 +688,7 @@ private SentryEvent processFeedbackEvent(
     return feedbackEvent;
   }
 
+  @Deprecated
   @Override
   public void captureUserFeedback(final @NotNull UserFeedback userFeedback) {
     Objects.requireNonNull(userFeedback, "SentryEvent is required.");
@@ -714,6 +715,7 @@ public void captureUserFeedback(final @NotNull UserFeedback userFeedback) {
     }
   }
 
+  @Deprecated
   private @NotNull SentryEnvelope buildEnvelope(final @NotNull UserFeedback userFeedback) {
     final List<SentryEnvelopeItem> envelopeItems = new ArrayList<>();
 
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
index dd47d2b99d0..dbbc36524db 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
@@ -169,6 +169,7 @@ public final class SentryEnvelopeItem {
     }
   }
 
+  @Deprecated
   public static SentryEnvelopeItem fromUserFeedback(
       final @NotNull ISerializer serializer, final @NotNull UserFeedback userFeedback) {
     Objects.requireNonNull(serializer, "ISerializer is required.");
diff --git a/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java b/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java
index 2a0ead54234..a72b352317e 100644
--- a/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java
@@ -91,10 +91,10 @@ public final class SentryFeedbackOptions {
   /** Callback called when there is an error submitting feedback via the prepared form. */
   private @Nullable SentryFeedbackCallback onSubmitError;
 
-  private @NotNull IDialogHandler iDialogHandler;
+  private @NotNull IFormHandler iFormHandler;
 
-  public SentryFeedbackOptions(@NotNull IDialogHandler iDialogHandler) {
-    this.iDialogHandler = iDialogHandler;
+  SentryFeedbackOptions(@NotNull IFormHandler iFormHandler) {
+    this.iFormHandler = iFormHandler;
   }
 
   /** Creates a copy of the passed {@link SentryFeedbackOptions}. */
@@ -121,7 +121,7 @@ public SentryFeedbackOptions(final @NotNull SentryFeedbackOptions other) {
     this.onFormClose = other.onFormClose;
     this.onSubmitSuccess = other.onSubmitSuccess;
     this.onSubmitError = other.onSubmitError;
-    this.iDialogHandler = other.iDialogHandler;
+    this.iFormHandler = other.iFormHandler;
   }
 
   /**
@@ -535,23 +535,23 @@ public void setOnSubmitError(final @Nullable SentryFeedbackCallback onSubmitErro
   }
 
   /**
-   * Sets the dialog handler to be used to show the feedback form.
+   * Sets the form handler to be used to show the feedback form.
    *
-   * @param iDialogHandler the dialog handler to be used to show the feedback form
+   * @param iFormHandler the form handler to be used to show the feedback form
    */
   @ApiStatus.Internal
-  public void setDialogHandler(final @NotNull IDialogHandler iDialogHandler) {
-    this.iDialogHandler = iDialogHandler;
+  public void setFormHandler(final @NotNull IFormHandler iFormHandler) {
+    this.iFormHandler = iFormHandler;
   }
 
   /**
-   * Gets the dialog handler to be used to show the feedback form.
+   * Gets the form handler to be used to show the feedback form.
    *
-   * @return the dialog handler to be used to show the feedback form
+   * @return the form handler to be used to show the feedback form
    */
   @ApiStatus.Internal
-  public @NotNull IDialogHandler getDialogHandler() {
-    return iDialogHandler;
+  public @NotNull IFormHandler getFormHandler() {
+    return iFormHandler;
   }
 
   @Override
@@ -609,8 +609,8 @@ public interface SentryFeedbackCallback {
   }
 
   @ApiStatus.Internal
-  public interface IDialogHandler {
-    void showDialog(
+  public interface IFormHandler {
+    void showForm(
         final @Nullable SentryId associatedEventId,
         final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator);
   }
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 86086f8816b..a6f78cfad9c 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -3397,7 +3397,7 @@ private SentryOptions(final boolean empty) {
     feedbackOptions =
         new SentryFeedbackOptions(
             (associatedEventId, configurator) ->
-                logger.log(SentryLevel.WARNING, "showDialog() can only be called in Android."));
+                logger.log(SentryLevel.WARNING, "showForm() can only be called in Android."));
 
     if (!empty) {
       setSpanFactory(SpanFactoryFactory.create(new LoadClass(), NoOpLogger.getInstance()));
diff --git a/sentry/src/main/java/io/sentry/UserFeedback.java b/sentry/src/main/java/io/sentry/UserFeedback.java
index b580744ee77..b9d0ade0f9d 100644
--- a/sentry/src/main/java/io/sentry/UserFeedback.java
+++ b/sentry/src/main/java/io/sentry/UserFeedback.java
@@ -8,7 +8,13 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-/** Adds additional information about what happened to an event. */
+/**
+ * Adds additional information about what happened to an event.
+ *
+ * @deprecated Use {@link io.sentry.protocol.Feedback} with {@link Sentry#feedback()}.{@link
+ *     IFeedbackApi#capture(io.sentry.protocol.Feedback) capture(feedback)} instead.
+ */
+@Deprecated
 public final class UserFeedback implements JsonUnknown, JsonSerializable {
 
   private final SentryId eventId;
diff --git a/sentry/src/test/java/io/sentry/HubAdapterTest.kt b/sentry/src/test/java/io/sentry/HubAdapterTest.kt
index 9b97d8935f7..0dbb6a43c11 100644
--- a/sentry/src/test/java/io/sentry/HubAdapterTest.kt
+++ b/sentry/src/test/java/io/sentry/HubAdapterTest.kt
@@ -14,6 +14,7 @@ import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.reset
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
 
 class HubAdapterTest {
   val scopes: IScopes = mock()
@@ -63,6 +64,7 @@ class HubAdapterTest {
     val hint = Hint()
     val scopeCallback = mock<ScopeCallback>()
     val feedback = Feedback("message")
+    whenever(scopes.feedback()).thenReturn(FeedbackApi(scopes))
     HubAdapter.getInstance().captureFeedback(feedback)
     verify(scopes).captureFeedback(eq(feedback))
 
diff --git a/sentry/src/test/java/io/sentry/ScopesAdapterTest.kt b/sentry/src/test/java/io/sentry/ScopesAdapterTest.kt
index 43cb5b155a7..1de22cfd3c3 100644
--- a/sentry/src/test/java/io/sentry/ScopesAdapterTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopesAdapterTest.kt
@@ -14,6 +14,7 @@ import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.reset
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
 
 class ScopesAdapterTest {
   val scopes: IScopes = mock()
@@ -63,6 +64,7 @@ class ScopesAdapterTest {
     val scopeCallback = mock<ScopeCallback>()
     val hint = mock<Hint>()
     val feedback = Feedback("message")
+    whenever(scopes.feedback()).thenReturn(FeedbackApi(scopes))
     ScopesAdapter.getInstance().captureFeedback(feedback)
     verify(scopes).captureFeedback(eq(feedback))
 
diff --git a/sentry/src/test/java/io/sentry/SentryFeedbackOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryFeedbackOptionsTest.kt
index a50aff02dc5..e4b96cb17d0 100644
--- a/sentry/src/test/java/io/sentry/SentryFeedbackOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryFeedbackOptionsTest.kt
@@ -1,6 +1,6 @@
 package io.sentry
 
-import io.sentry.SentryFeedbackOptions.IDialogHandler
+import io.sentry.SentryFeedbackOptions.IFormHandler
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import org.mockito.kotlin.mock
@@ -8,7 +8,7 @@ import org.mockito.kotlin.mock
 class SentryFeedbackOptionsTest {
   @Test
   fun `feedback options is initialized with default values`() {
-    val options = SentryFeedbackOptions(mock<IDialogHandler>())
+    val options = SentryFeedbackOptions(mock<IFormHandler>())
     assertEquals(false, options.isNameRequired)
     assertEquals(true, options.isShowName)
     assertEquals(false, options.isEmailRequired)
@@ -35,7 +35,7 @@ class SentryFeedbackOptionsTest {
   @Test
   fun `feedback options copy constructor`() {
     val options =
-      SentryFeedbackOptions(mock<IDialogHandler>()).apply {
+      SentryFeedbackOptions(mock<IFormHandler>()).apply {
         isNameRequired = true
         isShowName = false
         isEmailRequired = true
@@ -80,6 +80,6 @@ class SentryFeedbackOptionsTest {
     assertEquals(options.onFormClose, optionsCopy.onFormClose)
     assertEquals(options.onSubmitSuccess, optionsCopy.onSubmitSuccess)
     assertEquals(options.onSubmitError, optionsCopy.onSubmitError)
-    assertEquals(options.dialogHandler, optionsCopy.dialogHandler)
+    assertEquals(options.formHandler, optionsCopy.formHandler)
   }
 }
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index da014b30f74..e08d0ed8f72 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -907,8 +907,8 @@ class SentryOptionsTest {
         setLogger(logger)
         isDebug = true
       }
-    options.feedbackOptions.dialogHandler.showDialog(mock(), mock())
-    verify(logger).log(eq(SentryLevel.WARNING), eq("showDialog() can only be called in Android."))
+    options.feedbackOptions.formHandler.showForm(mock(), mock())
+    verify(logger).log(eq(SentryLevel.WARNING), eq("showForm() can only be called in Android."))
   }
 
   @Test
diff --git a/sentry/src/test/java/io/sentry/SentryTest.kt b/sentry/src/test/java/io/sentry/SentryTest.kt
index 25f45816b74..3712b083de7 100644
--- a/sentry/src/test/java/io/sentry/SentryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTest.kt
@@ -1,6 +1,6 @@
 package io.sentry
 
-import io.sentry.SentryFeedbackOptions.IDialogHandler
+import io.sentry.SentryFeedbackOptions.IFormHandler
 import io.sentry.SentryOptions.ProfilesSamplerCallback
 import io.sentry.SentryOptions.TracesSamplerCallback
 import io.sentry.backpressure.BackpressureMonitor
@@ -1504,39 +1504,39 @@ class SentryTest {
   }
 
   @Test
-  fun `showUserFeedbackDialog forwards to feedbackOptions_dialogHandler`() {
-    val mockDialogHandler = mock<IDialogHandler>()
+  fun `feedback show forwards to feedbackOptions_formHandler`() {
+    val mockFormHandler = mock<IFormHandler>()
     initForTest {
       it.dsn = dsn
-      it.feedbackOptions.dialogHandler = mockDialogHandler
+      it.feedbackOptions.setFormHandler(mockFormHandler)
     }
-    Sentry.showUserFeedbackDialog()
-    verify(mockDialogHandler).showDialog(eq(null), eq(null))
+    Sentry.feedback().show()
+    verify(mockFormHandler).showForm(eq(null), eq(null))
   }
 
   @Test
-  fun `showUserFeedbackDialog forwards to feedbackOptions_dialogHandler with configurator`() {
-    val mockDialogHandler = mock<IDialogHandler>()
+  fun `feedback show forwards to feedbackOptions_formHandler with configurator`() {
+    val mockFormHandler = mock<IFormHandler>()
     val configurator = mock<SentryFeedbackOptions.OptionsConfigurator>()
     initForTest {
       it.dsn = dsn
-      it.feedbackOptions.dialogHandler = mockDialogHandler
+      it.feedbackOptions.setFormHandler(mockFormHandler)
     }
-    Sentry.showUserFeedbackDialog(configurator)
-    verify(mockDialogHandler).showDialog(eq(null), eq(configurator))
+    Sentry.feedback().show(configurator)
+    verify(mockFormHandler).showForm(eq(null), eq(configurator))
   }
 
   @Test
-  fun `showUserFeedbackDialog forwards to feedbackOptions_dialogHandler with associatedEventId and configurator`() {
-    val mockDialogHandler = mock<IDialogHandler>()
+  fun `feedback show forwards to feedbackOptions_formHandler with associatedEventId and configurator`() {
+    val mockFormHandler = mock<IFormHandler>()
     val configurator = mock<SentryFeedbackOptions.OptionsConfigurator>()
     val associatedEventId = SentryId()
     initForTest {
       it.dsn = dsn
-      it.feedbackOptions.dialogHandler = mockDialogHandler
+      it.feedbackOptions.setFormHandler(mockFormHandler)
     }
-    Sentry.showUserFeedbackDialog(associatedEventId, configurator)
-    verify(mockDialogHandler).showDialog(eq(associatedEventId), eq(configurator))
+    Sentry.feedback().show(associatedEventId, configurator)
+    verify(mockFormHandler).showForm(eq(associatedEventId), eq(configurator))
   }
 
   @Test

From e63ad341cb0d79622e0dbafcf1fe9a2ec5e5f12b Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 30 Apr 2026 13:26:36 +0200
Subject: [PATCH 125/391] ref(feedback): Deprecate SentryUserFeedbackButton
 (#5350)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* ref(feedback): Rename Dialog to Form across feedback APIs

Rename SentryUserFeedbackDialog to SentryUserFeedbackForm as the primary
class. Keep SentryUserFeedbackDialog as a deprecated subclass for backward
compatibility.

Also rename internal APIs to use Form naming consistently:
- IDialogHandler -> IFormHandler
- showDialog -> showForm
- setDialogHandler/getDialogHandler -> setFormHandler/getFormHandler
- AndroidUserFeedbackIDialogHandler -> AndroidUserFeedbackFormHandler

Add deprecated Sentry.showUserFeedbackDialog() overloads that delegate to
the new Sentry.showUserFeedbackForm() methods.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): Preserve binary compatibility for deprecated Builder constructors

Use SentryUserFeedbackDialog.OptionsConfiguration as the parameter type
in the deprecated Builder constructors so old compiled code looking for
the original descriptor still resolves correctly.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Make internal ctor package-private

* Add missing deprecated annotaiton

* Fix api

* docs(changelog): Add deprecation entry for feedback Dialog to Form rename

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs(changelog): Note removal in next major version

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* feat(feedback): Add Sentry.feedback() API

Introduce IFeedbackApi with showForm() and capture() methods,
accessible via Sentry.feedback(). This consolidates all feedback
operations under a single API entry point.

Deprecate Sentry.showUserFeedbackForm(), Sentry.showUserFeedbackDialog(),
Sentry.captureFeedback(), and Sentry.captureUserFeedback() in favor of the
new Sentry.feedback() API. All deprecated methods will be removed in the
next major version.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs(changelog): Update section to Features and remove unpublished API

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref(feedback): Move FeedbackApi to IScopes

Add feedback() method to IScopes, matching the pattern used by
logger() and metrics(). FeedbackApi takes an IScopes reference instead
of using Sentry.getCurrentScopes() statically.

Implemented in Scopes, NoOpScopes, NoOpHub, HubAdapter, HubScopesWrapper,
and ScopesAdapter. Sentry.feedback() now delegates to
getCurrentScopes().feedback().

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref: Rename showForm() to show() on IFeedbackApi

Since the method is already namespaced under feedback(), the extra
"Form" suffix is redundant. This aligns with the convention used by
logger() and metrics().

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore: Deprecate UserFeedback and captureUserFeedback, delete showUserFeedbackForm

Deprecate the old `UserFeedback` class and `captureUserFeedback()`
across IScopes, ISentryClient, and all implementations in favor of
`Sentry.feedback().capture()` with the new `Feedback` type.

Delete `Sentry.showUserFeedbackForm()` (3 overloads) as it was never
published.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore: Deprecate SentryEnvelopeItem.fromUserFeedback()

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore: Deprecate SentryClient.buildEnvelope(UserFeedback)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref: Remove unnecessary SuppressWarnings("deprecation")

Deprecated methods don't need to suppress deprecation warnings for
referencing other deprecated types — the deprecation annotation itself
is sufficient.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix test

* remove redudndant deprecated annotations

* fix test

* ref(feedback): Deprecate SentryUserFeedbackButton

* Changelog

* chore: Deprecate SentryUserFeedbackButton in sentry-compose

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

* message

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                                              | 2 ++
 .../io/sentry/android/core/SentryUserFeedbackButton.java  | 8 ++++++++
 .../kotlin/io/sentry/compose/SentryUserFeedbackButton.kt  | 1 +
 3 files changed, 11 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4d1a581769c..beabdfb7f15 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,8 @@
   - `Sentry.captureUserFeedback()` and `UserFeedback` are deprecated in favor of `Sentry.feedback().capture()` with the new `Feedback` type
   - `SentryUserFeedbackDialog` is deprecated in favor of `SentryUserFeedbackForm`
   - All deprecated APIs will be removed in the next major version
+- Deprecate `SentryUserFeedbackButton` (View-based and Compose-based) ([#5350](https://github.com/getsentry/sentry-java/pull/5350))
+  - It will be removed in the next major version
 
 ### Dependencies
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackButton.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackButton.java
index 729dfd0b4e7..f842f18674b 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackButton.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackButton.java
@@ -10,25 +10,33 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+/**
+ * @deprecated `SentryUserFeedbackButton` will be removed in the next major version
+ */
+@Deprecated
 public class SentryUserFeedbackButton extends Button {
 
   private @Nullable OnClickListener delegate;
 
+  @Deprecated
   public SentryUserFeedbackButton(Context context) {
     super(context);
     init(context, null, 0, 0);
   }
 
+  @Deprecated
   public SentryUserFeedbackButton(Context context, AttributeSet attrs) {
     super(context, attrs);
     init(context, attrs, 0, 0);
   }
 
+  @Deprecated
   public SentryUserFeedbackButton(Context context, AttributeSet attrs, int defStyleAttr) {
     super(context, attrs, defStyleAttr);
     init(context, attrs, defStyleAttr, 0);
   }
 
+  @Deprecated
   public SentryUserFeedbackButton(
       Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
     super(context, attrs, defStyleAttr, defStyleRes);
diff --git a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryUserFeedbackButton.kt b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryUserFeedbackButton.kt
index 0836c826d32..d82451b79e2 100644
--- a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryUserFeedbackButton.kt
+++ b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryUserFeedbackButton.kt
@@ -15,6 +15,7 @@ import androidx.compose.ui.unit.dp
 import io.sentry.Sentry
 import io.sentry.SentryFeedbackOptions
 
+@Deprecated("`SentryUserFeedbackButton` will be removed in the next major version")
 @Composable
 public fun SentryUserFeedbackButton(
   modifier: Modifier = Modifier,

From 867648ba476b1a8bf3febf364387743e635cdf58 Mon Sep 17 00:00:00 2001
From: Mischan Toosarani-Hausberger <mischan@abovevacant.com>
Date: Mon, 4 May 2026 08:06:33 +0200
Subject: [PATCH 126/391] fix: git-fallback for tombstone proto schema check
 (#5356)

---
 scripts/check-tombstone-proto-schema.sh | 228 ++++++++++++++++++++++--
 1 file changed, 211 insertions(+), 17 deletions(-)

diff --git a/scripts/check-tombstone-proto-schema.sh b/scripts/check-tombstone-proto-schema.sh
index abb7212c4af..ecf492af7e8 100755
--- a/scripts/check-tombstone-proto-schema.sh
+++ b/scripts/check-tombstone-proto-schema.sh
@@ -1,25 +1,219 @@
 #!/usr/bin/env bash
-set -euo pipefail
+set -Eeuo pipefail
 
 TRACKED_COMMIT="981d145117e8992842cdddee555c57e60c7a220a"
+REMOTE_URL='https://android.googlesource.com/platform/system/core'
+REMOTE_BRANCH='main'
+PROTO_PATH='debuggerd/proto/tombstone.proto'
+GITILES_REF="refs/heads/${REMOTE_BRANCH}"
+GITILES_LOG_URL="${REMOTE_URL}/+log/${GITILES_REF}/${PROTO_PATH}?format=JSON"
 
-# tail -n +2 to remove the magic anti-XSSI prefix from the Gitiles JSON response
-LATEST_COMMIT=$(curl -sf \
-  'https://android.googlesource.com/platform/system/core/+log/refs/heads/main/debuggerd/proto/tombstone.proto?format=JSON' \
-  | tail -n +2 \
-  | jq -r '.log[0].commit')
+MODE=auto
+case "${1:-}" in
+  "")
+    ;;
+  --git-only)
+    MODE=git
+    ;;
+  --gitiles-only)
+    MODE=gitiles
+    ;;
+  *)
+    echo "Usage: $0 [--git-only|--gitiles-only]" >&2
+    exit 2
+    ;;
+esac
 
-if [ -z "$LATEST_COMMIT" ] || [ "$LATEST_COMMIT" = "null" ]; then
-  echo "ERROR: Failed to fetch latest commit from Gitiles" >&2
-  exit 1
-fi
+TEMP_FILES=()
+TEMP_DIRS=()
+LATEST_COMMIT=""
 
-echo "Tracked commit: $TRACKED_COMMIT"
-echo "Latest commit:  $LATEST_COMMIT"
+error() {
+  echo "ERROR: $*" >&2
+}
 
-if [ "$LATEST_COMMIT" != "$TRACKED_COMMIT" ]; then
-  echo "Schema has been updated! Latest: https://android.googlesource.com/platform/system/core/+/${LATEST_COMMIT}/debuggerd/proto/tombstone.proto"
-  exit 1
-fi
+show_output() {
+  local label=$1
+  local file=$2
 
-echo "Schema is up to date."
+  if [ -s "$file" ]; then
+    echo "$label:" >&2
+    sed 's/^/  /' "$file" >&2
+  fi
+}
+
+require_command() {
+  local command_name=$1
+
+  if ! command -v "$command_name" >/dev/null 2>&1; then
+    error "Required command not found: $command_name"
+    return 1
+  fi
+}
+
+make_temp_file() {
+  local file
+  file=$(mktemp)
+  TEMP_FILES+=("$file")
+  printf '%s\n' "$file"
+}
+
+make_temp_dir() {
+  local dir
+  dir=$(mktemp -d)
+  TEMP_DIRS+=("$dir")
+  printf '%s\n' "$dir"
+}
+
+cleanup() {
+  local path
+
+  for path in "${TEMP_FILES[@]}"; do
+    rm -f "$path"
+  done
+
+  for path in "${TEMP_DIRS[@]}"; do
+    rm -rf "$path"
+  done
+}
+
+handle_unexpected_error() {
+  local exit_code=$?
+  error "Unexpected failure at line $1 while running: $2 (exit $exit_code)"
+  exit "$exit_code"
+}
+
+trap 'handle_unexpected_error "$LINENO" "$BASH_COMMAND"' ERR
+trap cleanup EXIT
+
+run_gitiles_check() {
+  local response_file
+  local stderr_file
+  local status
+
+  require_command curl || return 1
+  require_command jq || return 1
+
+  response_file=$(make_temp_file)
+  stderr_file=$(make_temp_file)
+
+  if curl -fsS "$GITILES_LOG_URL" -o "$response_file" 2>"$stderr_file"; then
+    :
+  else
+    status=$?
+    error "Failed to fetch Gitiles history from:"
+    error "  $GITILES_LOG_URL"
+    error "curl exited with status $status."
+    show_output "curl output" "$stderr_file"
+    return 1
+  fi
+
+  if LATEST_COMMIT=$(tail -n +2 "$response_file" | jq -er '.log[0].commit' 2>"$stderr_file"); then
+    :
+  else
+    status=$?
+    error "Failed to parse the latest commit from the Gitiles response."
+    error "jq exited with status $status."
+    show_output "jq output" "$stderr_file"
+    echo "Response preview:" >&2
+    head -n 20 "$response_file" >&2
+    return 1
+  fi
+
+  if [ -z "$LATEST_COMMIT" ]; then
+    error "Gitiles response did not contain a commit hash."
+    echo "Response preview:" >&2
+    head -n 20 "$response_file" >&2
+    return 1
+  fi
+}
+
+run_git_check() {
+  local repo_dir
+  local stderr_file
+  local status
+
+  require_command git || return 1
+
+  repo_dir=$(make_temp_dir)
+  stderr_file=$(make_temp_file)
+
+  if GIT_TERMINAL_PROMPT=0 git clone \
+    --quiet \
+    --filter=blob:none \
+    --single-branch \
+    --branch "$REMOTE_BRANCH" \
+    --no-checkout \
+    "$REMOTE_URL" "$repo_dir" 2>"$stderr_file"; then
+    :
+  else
+    status=$?
+    error "Failed to clone $REMOTE_BRANCH from:"
+    error "  $REMOTE_URL"
+    error "git clone exited with status $status."
+    show_output "git clone output" "$stderr_file"
+    return 1
+  fi
+
+  if LATEST_COMMIT=$(git -C "$repo_dir" log -n 1 --format=%H HEAD -- "$PROTO_PATH" 2>"$stderr_file"); then
+    :
+  else
+    status=$?
+    error "Failed to determine the latest commit that modified:"
+    error "  $PROTO_PATH"
+    error "git log exited with status $status."
+    show_output "git log output" "$stderr_file"
+    return 1
+  fi
+
+  if [ -z "$LATEST_COMMIT" ]; then
+    error "Git history did not contain a commit for:"
+    error "  $PROTO_PATH"
+    return 1
+  fi
+}
+
+report_result() {
+  echo "Tracked commit: $TRACKED_COMMIT"
+  echo "Latest commit:  $LATEST_COMMIT"
+
+  if [ "$LATEST_COMMIT" != "$TRACKED_COMMIT" ]; then
+    echo "Schema has been updated! Latest: ${REMOTE_URL}/+/${LATEST_COMMIT}/${PROTO_PATH}"
+    exit 1
+  fi
+
+  echo "Schema is up to date."
+}
+
+case "$MODE" in
+  auto)
+    if run_gitiles_check; then
+      report_result
+      exit 0
+    fi
+
+    echo "Falling back to git-based check." >&2
+    if run_git_check; then
+      report_result
+      exit 0
+    fi
+
+    exit 1
+    ;;
+  gitiles)
+    if run_gitiles_check; then
+      report_result
+      exit 0
+    fi
+
+    exit 1
+    ;;
+  git)
+    if run_git_check; then
+      report_result
+      exit 0
+    fi
+
+    exit 1
+    ;;
+esac

From b469e467b75db6863d3cf24629c2d9b3938961b1 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Mon, 4 May 2026 11:38:50 +0200
Subject: [PATCH 127/391] fix(feedback): Show soft input keyboard on the
 Feedback form (#5359)

* fix(feedback): Show soft input keyboard on the Feedback form

* test(feedback): Add test verifying soft keyboard is not blocked by dialog window flags

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* changelog(feedback): Add entry for soft keyboard fix

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* formatting

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                        |  4 ++++
 .../sentry/android/core/SentryUserFeedbackForm.java |  6 ++++++
 .../android/core/SentryUserFeedbackFormTest.kt      | 13 +++++++++++++
 3 files changed, 23 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index beabdfb7f15..71af3a9e159 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,10 @@
 - Deprecate `SentryUserFeedbackButton` (View-based and Compose-based) ([#5350](https://github.com/getsentry/sentry-java/pull/5350))
   - It will be removed in the next major version
 
+### Fixes
+
+- Fix soft input keyboard not being shown on the Feedback form ([#5359](https://github.com/getsentry/sentry-java/pull/5359))
+
 ### Dependencies
 
 - Bump Native SDK from v0.13.7 to v0.13.8 ([#5334](https://github.com/getsentry/sentry-java/pull/5334))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
index 0babe475491..722fc9110db 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
@@ -4,6 +4,8 @@
 import android.content.Context;
 import android.os.Bundle;
 import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
 import android.widget.Button;
 import android.widget.EditText;
 import android.widget.ImageView;
@@ -55,6 +57,10 @@ public void setCancelable(boolean cancelable) {
   protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.sentry_dialog_user_feedback);
+    final @Nullable Window window = getWindow();
+    if (window != null) {
+      window.clearFlags(WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM);
+    }
     setCancelable(isCancelable);
 
     final @NotNull SentryFeedbackOptions feedbackOptions =
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt
index 04f6a35716b..9df2a16d72e 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt
@@ -1,6 +1,7 @@
 package io.sentry.android.core
 
 import android.content.Context
+import android.view.WindowManager
 import android.widget.TextView
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
@@ -17,6 +18,7 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
+import kotlin.test.assertNotNull
 import org.junit.runner.RunWith
 import org.mockito.Mockito.mockStatic
 import org.mockito.kotlin.eq
@@ -130,4 +132,15 @@ class SentryUserFeedbackFormTest {
     // And the original options should not be modified
     assertNotEquals("custom title", fixture.options.feedbackOptions.formTitle)
   }
+
+  @Test
+  fun `dialog window does not have FLAG_ALT_FOCUSABLE_IM so soft keyboard can appear`() {
+    fixture.options.isEnabled = true
+    val sut = fixture.getSut()
+    sut.show()
+    val window = sut.window
+    assertNotNull(window)
+    val flags = window.attributes.flags
+    assertEquals(0, flags and WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM)
+  }
 }

From 8558cacae503ef0248a7afe38f2f4e84610c3c7d Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Mon, 4 May 2026 14:34:45 +0200
Subject: [PATCH 128/391] feat(feedback): Add per-form shake detection and
 sample app showcases (#5353)

* feat(feedback): Add per-form shake detection and sample app showcases

Resolve feedback options once in the constructor and reuse them in
onCreate, avoiding duplicate resolution. Add per-form shake-to-show
support via SentryShakeDetector that skips activation when the global
FeedbackShakeIntegration is already enabled. Update sample app with
custom form builder, auto-dismiss, programmatic capture, and
shake-to-show examples.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs(changelog): Add per-form shake detection entry

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Format code

* docs(changelog): Add usage example for per-form shake detection

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs(changelog): Use Kotlin example and clarify per-screen usage

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref(feedback): Extract shared shake listener in SentryUserFeedbackForm

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |   7 +
 .../android/core/SentryUserFeedbackForm.java  | 132 ++++++++++++++++--
 .../src/main/AndroidManifest.xml              |   1 +
 .../io/sentry/samples/android/MainActivity.kt | 107 +++++++++++++-
 4 files changed, 232 insertions(+), 15 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 71af3a9e159..042e87b9713 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,13 @@
   - All deprecated APIs will be removed in the next major version
 - Deprecate `SentryUserFeedbackButton` (View-based and Compose-based) ([#5350](https://github.com/getsentry/sentry-java/pull/5350))
   - It will be removed in the next major version
+- Add per-form shake-to-show support for `SentryUserFeedbackForm` ([#5353](https://github.com/getsentry/sentry-java/pull/5353))
+  - Useful for enabling shake-to-report on specific screens instead of globally
+  ```kotlin
+  SentryUserFeedbackForm.Builder(activity)
+    .configurator { it.isUseShakeGesture = true }
+    .create()
+  ```
 
 ### Fixes
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
index 722fc9110db..2800d5670a8 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
@@ -1,7 +1,10 @@
 package io.sentry.android.core;
 
+import android.app.Activity;
 import android.app.AlertDialog;
+import android.app.Application;
 import android.content.Context;
+import android.content.ContextWrapper;
 import android.os.Bundle;
 import android.view.View;
 import android.view.Window;
@@ -20,6 +23,7 @@
 import io.sentry.protocol.Feedback;
 import io.sentry.protocol.SentryId;
 import io.sentry.protocol.User;
+import java.lang.ref.WeakReference;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -30,8 +34,10 @@ public class SentryUserFeedbackForm extends AlertDialog {
   private final @Nullable SentryId associatedEventId;
   private @Nullable OnDismissListener delegate;
 
-  private final @Nullable OptionsConfiguration configuration;
-  private final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator;
+  private final @NotNull SentryFeedbackOptions resolvedFeedbackOptions;
+
+  private @Nullable SentryShakeDetector shakeDetector;
+  private @Nullable Application.ActivityLifecycleCallbacks shakeLifecycleCallbacks;
 
   SentryUserFeedbackForm(
       final @NotNull Context context,
@@ -41,9 +47,118 @@ public class SentryUserFeedbackForm extends AlertDialog {
       final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {
     super(context, themeResId);
     this.associatedEventId = associatedEventId;
-    this.configuration = configuration;
-    this.configurator = configurator;
+    this.resolvedFeedbackOptions =
+        new SentryFeedbackOptions(Sentry.getCurrentScopes().getOptions().getFeedbackOptions());
+    if (configuration != null) {
+      configuration.configure(context, resolvedFeedbackOptions);
+    }
+    if (configurator != null) {
+      configurator.configure(resolvedFeedbackOptions);
+    }
     SentryIntegrationPackageStorage.getInstance().addIntegration("UserFeedbackWidget");
+    maybeStartShakeDetection(context);
+  }
+
+  private void maybeStartShakeDetection(final @NotNull Context context) {
+    final @NotNull SentryFeedbackOptions globalFeedbackOptions =
+        Sentry.getCurrentScopes().getOptions().getFeedbackOptions();
+    if (!resolvedFeedbackOptions.isUseShakeGesture() || globalFeedbackOptions.isUseShakeGesture()) {
+      return;
+    }
+    final @Nullable Activity activity = getActivity(context);
+    if (activity == null) {
+      return;
+    }
+    final @NotNull SentryOptions options = Sentry.getCurrentScopes().getOptions();
+    shakeDetector = new SentryShakeDetector(options.getLogger());
+    final @NotNull WeakReference<Activity> activityRef = new WeakReference<>(activity);
+    shakeDetector.start(activity, shakeListener(activityRef));
+    final @NotNull Application app = activity.getApplication();
+    shakeLifecycleCallbacks = new ShakeLifecycleCallbacks(activityRef);
+    app.registerActivityLifecycleCallbacks(shakeLifecycleCallbacks);
+  }
+
+  private void stopShakeDetection() {
+    if (shakeDetector != null) {
+      shakeDetector.close();
+      shakeDetector = null;
+    }
+    if (shakeLifecycleCallbacks != null) {
+      final @Nullable Activity activity = getActivity(getContext());
+      if (activity != null) {
+        activity.getApplication().unregisterActivityLifecycleCallbacks(shakeLifecycleCallbacks);
+      }
+      shakeLifecycleCallbacks = null;
+    }
+  }
+
+  private @NotNull SentryShakeDetector.Listener shakeListener(
+      final @NotNull WeakReference<Activity> activityRef) {
+    return () -> {
+      final @Nullable Activity active = activityRef.get();
+      if (active != null && !active.isFinishing() && !active.isDestroyed()) {
+        active.runOnUiThread(
+            () -> {
+              if (!active.isFinishing() && !active.isDestroyed()) {
+                show();
+              }
+            });
+      }
+    };
+  }
+
+  private static @Nullable Activity getActivity(final @NotNull Context context) {
+    Context current = context;
+    while (current instanceof ContextWrapper) {
+      if (current instanceof Activity) {
+        return (Activity) current;
+      }
+      current = ((ContextWrapper) current).getBaseContext();
+    }
+    return null;
+  }
+
+  private class ShakeLifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
+    private final @NotNull WeakReference<Activity> activityRef;
+
+    ShakeLifecycleCallbacks(final @NotNull WeakReference<Activity> activityRef) {
+      this.activityRef = activityRef;
+    }
+
+    @Override
+    public void onActivityResumed(final @NotNull Activity activity) {
+      if (activity == activityRef.get() && shakeDetector != null) {
+        shakeDetector.start(activity, shakeListener(activityRef));
+      }
+    }
+
+    @Override
+    public void onActivityPaused(final @NotNull Activity activity) {
+      if (activity == activityRef.get() && shakeDetector != null) {
+        shakeDetector.stop();
+      }
+    }
+
+    @Override
+    public void onActivityDestroyed(final @NotNull Activity activity) {
+      if (activity == activityRef.get()) {
+        stopShakeDetection();
+      }
+    }
+
+    @Override
+    public void onActivityCreated(
+        final @NotNull Activity activity, final @Nullable Bundle savedInstanceState) {}
+
+    @Override
+    public void onActivityStarted(final @NotNull Activity activity) {}
+
+    @Override
+    public void onActivityStopped(final @NotNull Activity activity) {}
+
+    @Override
+    public void onActivitySaveInstanceState(
+        final @NotNull Activity activity, final @NotNull Bundle outState) {}
   }
 
   @Override
@@ -63,14 +178,7 @@ protected void onCreate(Bundle savedInstanceState) {
     }
     setCancelable(isCancelable);
 
-    final @NotNull SentryFeedbackOptions feedbackOptions =
-        new SentryFeedbackOptions(Sentry.getCurrentScopes().getOptions().getFeedbackOptions());
-    if (configuration != null) {
-      configuration.configure(getContext(), feedbackOptions);
-    }
-    if (configurator != null) {
-      configurator.configure(feedbackOptions);
-    }
+    final @NotNull SentryFeedbackOptions feedbackOptions = resolvedFeedbackOptions;
     final @NotNull TextView lblTitle = findViewById(R.id.sentry_dialog_user_feedback_title);
     final @NotNull ImageView imgLogo = findViewById(R.id.sentry_dialog_user_feedback_logo);
     final @NotNull TextView lblName = findViewById(R.id.sentry_dialog_user_feedback_txt_name);
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 548e5e8ac0d..26f526124b4 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -271,6 +271,7 @@
     <meta-data
       android:name="io.sentry.anr.enable-fingerprinting"
       android:value="true" />
+    <!-- Enable feedback on shake globally -->
     <meta-data
       android:name="io.sentry.feedback.use-shake-gesture"
       android:value="true" />
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
index 4c4ef05fb1a..e000b54e4cc 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
@@ -43,6 +43,7 @@ import androidx.compose.material.icons.filled.Settings
 import androidx.compose.material.icons.filled.Speed
 import androidx.compose.material.icons.filled.Videocam
 import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Button
 import androidx.compose.material3.ExperimentalMaterial3Api
 import androidx.compose.material3.Icon
 import androidx.compose.material3.MaterialTheme
@@ -62,6 +63,7 @@ import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.ExperimentalComposeUiApi
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.rotate
@@ -79,8 +81,9 @@ import io.sentry.MeasurementUnit
 import io.sentry.Sentry
 import io.sentry.SentryLogLevel
 import io.sentry.UpdateStatus
+import io.sentry.android.core.SentryUserFeedbackForm
 import io.sentry.compose.SentryTraced
-import io.sentry.compose.SentryUserFeedbackButton
+import io.sentry.protocol.Feedback
 import io.sentry.protocol.User
 import java.io.File
 import java.io.FileOutputStream
@@ -615,8 +618,106 @@ fun UserFeedbackScreen() {
       }
     }
 
-    // SentryUserFeedbackButton as a special item
-    item(span = { GridItemSpan(maxLineSpan) }) { SentryUserFeedbackButton(modifier = Modifier) }
+    // Bring up User Feedback Form from a custom button using the global Sentry.feedback() API
+    item(span = { GridItemSpan(maxLineSpan) }) {
+      Button(modifier = Modifier, onClick = { Sentry.feedback().show() }) {
+        Row(
+          verticalAlignment = Alignment.CenterVertically,
+          horizontalArrangement = Arrangement.Center,
+        ) {
+          Icon(
+            painter =
+              painterResource(
+                id = io.sentry.compose.R.drawable.sentry_user_feedback_compose_button_logo_24
+              ),
+            contentDescription = null,
+          )
+          Spacer(Modifier.padding(horizontal = 4.dp))
+          Text(text = "Report a Bug")
+        }
+      }
+    }
+
+    // Create a SentryUserFeedbackForm programmatically and show it
+    item(span = { GridItemSpan(maxLineSpan) }) {
+      Button(
+        modifier = Modifier,
+        onClick = {
+          SentryUserFeedbackForm.Builder(activity)
+            .configurator { options ->
+              options.formTitle = "Custom Form"
+              options.submitButtonLabel = "Send"
+              options.cancelButtonLabel = "Never mind"
+              options.messageLabel = "What happened?"
+              options.messagePlaceholder = "Describe the issue..."
+              options.isShowBranding = false
+              options.isNameRequired = true
+              options.isEmailRequired = true
+              options.setOnSubmitSuccess { feedback ->
+                Toast.makeText(activity, "Thanks for the feedback!", Toast.LENGTH_SHORT).show()
+              }
+            }
+            .create()
+            .show()
+        },
+      ) {
+        Text(text = "Custom Form (Builder)")
+      }
+    }
+
+    // Showcases how to manually show and dismiss a form programmatically
+    item(span = { GridItemSpan(maxLineSpan) }) {
+      Button(
+        modifier = Modifier,
+        onClick = {
+          val form =
+            SentryUserFeedbackForm.Builder(activity)
+              .configurator { options -> options.formTitle = "Quick! You have 2 seconds" }
+              .create()
+          form.show()
+          Handler(Looper.getMainLooper()).postDelayed({ form.dismiss() }, 2000)
+        },
+      ) {
+        Text(text = "Auto-dismiss Form (2s)")
+      }
+    }
+
+    // Send feedback programmatically without showing a form
+    item(span = { GridItemSpan(maxLineSpan) }) {
+      Button(
+        modifier = Modifier,
+        onClick = {
+          val feedback =
+            Feedback("The app crashed when I tapped the button").apply {
+              name = "Jane Doe"
+              contactEmail = "jane@example.com"
+              url = "https://example.com/page"
+            }
+          val eventId = Sentry.feedback().capture(feedback)
+          Toast.makeText(activity, "Feedback sent: $eventId", Toast.LENGTH_SHORT).show()
+        },
+      ) {
+        Text(text = "Send Feedback (no form)")
+      }
+    }
+
+    // Enable shake-to-show for a specific form instance
+    item(span = { GridItemSpan(maxLineSpan) }) {
+      Button(
+        modifier = Modifier,
+        onClick = {
+          SentryUserFeedbackForm.Builder(activity)
+            .configurator { options ->
+              options.isUseShakeGesture = true
+              options.formTitle = "Shake Feedback"
+            }
+            .create()
+          Toast.makeText(activity, "Shake your device to open the form!", Toast.LENGTH_SHORT).show()
+        },
+      ) {
+        Text(text = "Enable Shake-to-Show")
+      }
+    }
   }
 }
 

From 5bc94fce3ac6668d6626c29dc447e5fe430f7c70 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 5 May 2026 13:08:33 +0200
Subject: [PATCH 129/391] chore(deps): update Gradle to v9.5.0 (#5344)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md                             |   3 +++
 gradle/wrapper/gradle-wrapper.jar        | Bin 43764 -> 48966 bytes
 gradle/wrapper/gradle-wrapper.properties |   2 +-
 gradlew                                  |   7 ++-----
 gradlew.bat                              |   3 +--
 5 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 042e87b9713..2aee24e7775 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,6 +29,9 @@
 - Bump Native SDK from v0.13.7 to v0.13.8 ([#5334](https://github.com/getsentry/sentry-java/pull/5334))
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0138)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.13.7...0.13.8)
+- Bump Gradle from v9.4.1 to v9.5.0 ([#5344](https://github.com/getsentry/sentry-java/pull/5344))
+  - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v950)
+  - [diff](https://github.com/gradle/gradle/compare/v9.4.1...v9.5.0)
 
 ## 8.40.0
 
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 1b33c55baabb587c669f562ae36f953de2481846..d997cfc60f4cff0e7451d19d49a82fa986695d07 100644
GIT binary patch
delta 40557
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%0DLyP-h
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
Kt*`#|wEG{3k;I+=

delta 35566
zcmXt;Q+OR**RIo;jhhuWwr$&NY}-y&xMHiZZ98df+je7n_x=8BpU<N?o@d}5W9Sq7
zei6LZ<~uNI9KMecMeHfyCG`Cd<fa)`W7v$zp)uc59poIVY~W{im8<tO*Ro0sLp72;
zE!))US=VX+w*uMCK%0`bc;`UM%30zJOI<fYav%7Z%7llcYQ<thl-axE-D>OVeNR_=
zZo6#k03c<ZqW~9LPkZ^v1F84r5*B^|OHl>}HU-Y|`(JM`Ft8-B#BX9Wi8V~fiPZH!
z6D^Pt5f}ooV!6sL+$;y{6M@JyKm%A9M7`#9&D#Mi;p*8UpNYeSr`8FZ>S#)rBjSuA
z$xewN;-BF(sKjl;ZQqNKd^$164PuX}>xpAs*o>KQkPfZ`JNaKO^izgVP}PZXP((`_
zMef(Aj5tmpE{OS0bDk0@2a$kw-;8In&5Ke!N|2aO%=8AwA{Pv3qhl!2?3?<ERMK7c
z)huT*TVm1f&MwIpu<-=KqQjycsI!x+XMTL0B0)#fT(~$+?wpvsnrC4xYNnPv;al|T
z;ik`+Ddx-&GWzQVsxe9{m$|{>_kAZ5+^>9teyb6P!CAyF^@aHFL%{nWw~4=jfjNBp
z_aAtPxl9C!e|a#0rpnq1=t?M`-!W2}X%ur|^&GpJicINX)fu}{7)aHk$WWpfN;*O>
z0=if`wDXy61@4ib%f(48jC>y5pLrHmL)OsrrZUs+CZ8tL()5AdA7G4;WS}Q+?`azQ
zMs5zbU~8+$^tvKUwtnaIxud-MjfDNQz`gETC}c=Jb`M1$Gfv+MoR)kpot+~OiddCp
zGTs*LXjnmats=YGG2HpDwHIx=^<u%9og(J8zNSK&U<TdD{Ej|k$;iFrw6-+qQH+kY
z^>2(I)k*6YkO!r0FXQ1$irvdbV~E{~vi>7pXop$yZ}kkNI(Rh1{&k<!b9Q$+-==Q5
zC`BQGpuIt0n7?5o4un=-<HIno#e%40v|^im6W%V!x+a4(xy(%?#g+gPQYwR((FgmE
zG0KI=%J3dFkd$uQnvKI`#o(leLKl0BqE{!?NDX>d*)J=PBUS$wQ?M*Nytw3zsv7)|
z@`#b>AXtLb{Vr|4frQIuVsW4pXkhKA0fu^tBx?Z3rK1=hVdvXgXmm~K7%_H1S{>YX
z?5a&U1AsO;2+5vi%pP~gY<I%bS9U~No^Or7wM{|4f_GZb)ru(DQv(3cLn6S7=SK=8
z2iqJyDknGDu#B<;2zKqVey=HUU{0Xna>#*fE?w*jopA4zf__-Y(V|v2!({T^#7>2w
zk2eA%C{+Y7w7wvjmGn=C@<D^@gV^<HrM4#Cl+3|~+*qR(d4ydigmPHy`UD2|JoOnc
zfbHP{bDfRh!>`X|kqwhldBXgG>+gwB?aA1FMwg>lvKT#kQ$wLWJp$kARH58sp_omu
zSG&P``G=-y)&B}z3H&EU8<T1|J8&?thHnu6Q)3RgFz`YiT?m6uB%o-0E)e#auKMSP
z77k+q{1Bv+tRxO&KH%B7xMSYb(7icrGk;(t=o#^I29j)c0OmR`%6%OTC7tz>+}Zpn
z+xaSu$KCJi<p$voI6PubOpKm7KY-2d0>Khj2BgLz4Z?gzTHcSxm7GVm5qgvM2n-F(
z?BHds0_qxGgvtr9rkrgch>cos7Ej|A;|`b7(NAe3#KKlkm%Mw;-&v4s93Jt~g}CTY
z1v?dqbifFQBt<^bI3piZ7t?)@iWM<Hd^MX<P4T$&3hYHpQgOp*;ZthnZRx~$=1+A?
zChppy#<21#B7kd}4GRgydBv9Iqq1$lzLB&508Jz{%~7BWyodx5>~atqCK#UwlI`x3
z49S;qv$u^-rmGHH=4RrT@(ekniAWOxf+>ar$DwROPO1z1F#R6Y?Ze0(tNU|Q_Tr9{
zDR(@G{Q>VVE%Q*zA)ZQmhY5`k*))h*H;xKR)@=+y?zd=~{hUE3#Z~52UNU?P^}2IX
zKz#I8@h8B@gJAa3k!B0dr@jZMOfQga!)PSzDSnS;%<@%OoM=;@$CbsY>o!99z4i<=
z>xAR(z!ARw+X!$DK4ZX0+G?wB;UB%0T}y1`&sxk>u+LARC{i^?V>~iMyp-W5SNf~-
z2yQ|}#qxd$TYR6OKvQ7Swa{W>)(Q>I`aWI`vl*RY1f$3BfM(A=>5~Ru5oCjSCgXGY
zJmk={pHTz}SHGI`dxaj)xbV5zA@E#Zi|dZ{dxBik?e?F^?`1Qi=~Oo8`+%p2ZKk)Q
zsDeay|0AjTO3ZHL@SgufXI%-Cru|QJ&5-}o+&d9jqCo>Guu08YVcr14PfrlOi4yC^
z4;vHPh6a6x>o><AZQ@)<X=Yj0tM=5Yx$!x-T&7nR+4}|oL3B)#o7>3&LQ`H{b4Z~v
ztmVoJ@2%s^yUcO#*Zt!X1~75Qpxwp0WA}Q6MdIbuU|nSjRbM5!vUX!Nq{KInv2}_H
z8mW5-RV#%Bu%VAnt_Ie3v_dnRyKY2Ip>V-Uv%y1+1sr!!)=ZR;Pey~|O&eHemQH$2
zt%I9aR67o$3$|V{O`u0uCebII{vL~D-jtxBp3@Y-G~!uubhejn2oH+dPnkDOO_hyb
zk|W`}(D>0J!(wvE?#{RSs1PnTOxAe*@}gB&$B-8S+|?<(tg=G6I)Hb_P3WBVCCW?A
zTdV=-eOW@gl8?#8%p4=FUo$Z45JrK%qDv!X&K=tFJfUnY?1$+o;Z6Rg5E&wigc_rZ
zEF*ie&>~Lp?v3->I(1}Dy$M-4XOM}+C*g!^q(VeUt>>wqhzWCu_?Y_~1^s>;JrQCM
zp&g3`216ivXSFlfpGjE+=TWfg+##{}26-oI>P=E{2KQfZhLIrZW;B!G8C%dJ<QN+8
z&1w%y2tQHDWr)Jd|0Lh%d~H6&J`(DaG8&Yd*K9LqSe=T%ALD~=&fUR)1~+pA-HZ&_
z&1}!4i6C}72t3oRIXiPuNfIy0;}<f8RZ(LAEs5F#mRjUBwi}}$Pu@wts(4OQtW#<~
zDq>w{C3h)Bj<-$Y96)(B@rfEFUX!E{b+t4`H!6BQtw?D|V?A%oGQ)}D!GmR&``W=k
z;G4QdE{5z+3S+!uY_FDDG-zL?Apre_$^FK=L;wZ0p2Tz<l7xN7ZE)+C>YgRGN^2i*
zhFK0GXUYOByFycJck570#US`7RWt{GX%#by#mgETVF-J(X7=o7`YCvlDA5Z6{^$br
zW4GA#xiH0t$O1xRen>Vln)M0Q1XStA)y&Oz2^GRzKM|neBhL_;>+Ft<OAV1y?xMr3
zp%EsD{Su?P#Y<E}NXDdA_nXch34NvT-t97*?4lBj7PVAsg*|w7tNhb9BWXfnqt#%(
zftrlYCnZwHJtpZJ6ASkM#>%NKxXB){|Lg=M`F(&M0t`$S=6`nTASFwb$Dsh8x}%$7
zeetoHuDOV6E!B4-3gyZrivOr<?zGTGjW0YTYw`_hm1R+w4;YorOlwqydh*>K-24UU
zKHCyG=J;{|)8lndII~Z<!<D^Hal_9dg)3RRz>t>qw&9(#{jo{6{q=IV4933yg~&k2
z*Isk+IFp;sKOjf9Kp>4ALYxO|OrAUiot>p%Pio;%v`r#ab7y`JRij8JI64)P=RXf#
z3svpkjaQ^cpDb@HrT0O!TW_Z7dSRYxT90@X@$CN@z)~sBF-yV0(mvW&m4TfQ<FKCB
zA-T2GUerWaeiJ_vkHZKum>XNS^ozE00FBe}ppUPVn_X+H%@}X0vsVDqwK91x)NDi7
zQ~xqmDK&6V_`f9-R<!E~`y1X>4q^U1Vi`%HkZ%X45ux=9@bd}!4tnW^0L^Uweq}Gz
zP0dDCXS}JNkwzRXTthX$)-n%ON6Qps&&Tn+WTXuzRFzoJ*jkL%D6y?DcHDFf>2up$
z*u+O1&Nu=*{>_^rSls~jSzemMvR>F-rq22g3Q218)s_nDprtUWvb{t^3(*e4V<RZ(
zM_N@TC<STVJThPlErfH3fubS@v?YhYb!fNf^Trw{<arXOo#stXtZuPcRaww!6lZvs
zT__tI$@9X`l;}3rI8q7<ms52%Y)fP2iAbVSv{*^{Y7LHRx95Ota8;tp`c_x+*s1VE
z0Cpx?Uaa<Dx+L!)uLb<a(lxq$W*Y<}8u}7@wfRyLX_8BP-jR7bi90{+U%9%9YrCkT
zs0WDjR(Es7TysSG+bgJ~<uxW2Ts@{tP&~*bo&g0@4aB#3QYU6BTb9(k8P3B=#35s)
zXOvv)IJ0ckR3gBXDvWjpt2p~XdmYn#FLPsSBsVmQ!UQ#{?O&=RPe_=sRLco<2+Q!~
z?m7L2byl7A8|b1~dx+ZY(?Jrmw3n2{ht$<xVKn7j_~=9zc>|I1s<thmgl^#^&{FPh
z5i4Cj%GsYmzQhVrAlrr`vOJ#ehIf&1otU8g2iAB74|-tcW;yXtz|Yqk{lN6y%cgRc
zdD$C+b3zkI?8Qw(v3>cqB|ggzit1h@#PO-3Hkuk-oEEYTz<`{Fka5dETwb2?mR$gK
zyH(tn;N+o&HnS*A^M@xr2^LOkt9@ABP*Vi1siVpuGd76c1$mCn8K(;kk*OWl`iI$z
zA{A}}niCKa>rIqf*H}z7Qd%9{)SNT#2sR0+<VQ<jf~vk7tzmFPWWs1|-kbv^)+lFG
z-A{2x+_VW$11I=ZZp7&7M&91Fm^{}CDb`f%p8U5*dg@PM59UkMdb5pjhuJ8&GMQHW
z1GRZ>q@cXIvH`;uQ$Vo#U)ott<h?v@UjI<bIBwvpt<F$^5i|X;aT8~t+F<;-=Ii>A
z6bL`ObN7rDzT|vONxW^6!Q+uv4zr+RLtS^=Ohc;@aFwzN#U=Jmn~koRT>?)pka|tb
zB=og4ARFh1_;z-UrdP}<i<YS!I#1<=Sp(O#jBUlzoIH)Bm@(=xe|%F_FMQqV!xOd-
zE(SzW3u;NC6f^f^uq#LB#2#4mNNsKLT*4vZ-o`>W;N<^F?i;_PExRS*CoJ&exX}Q7
z^L{zO>X)j70zc2l1;6Xe&WfnENWMVpVky>o=GNID{Zn@1XcxtW<CT>6_B`oOZJ3|H
z!zVz7^c#Dy3e0y^Im1&+T7`?WzOida^%kJ4ft(4rbpg7@GT`?gFGC_;+do5rA4>Jv
z64M{Mj+OWl_bfJkFxuMWvu=nFy9=CLX#<Y|QaY|@tnJE$O=b!^G&)%kzd{m`mK%Ly
z&Wq!oi~BU~Z=yO`e8hW@U}tb0g*c>3^IO4#O&Q!UYDp!BPTIOL#+6?+_`<u5;}n1e
z0+`vtXQ~>1(%d?dgi&J1oI3n<D)Vca2=d<QYIeBA&HEnmm6w%wNWs+z<$2%}lxLN?
zG)}vj-U3MPPSa@FE;EK)b${o_a^Oj-My_~6BB^muK;Rep;BXYJL8!EP;+?8`Ke(4#
zBeJS15VOoAM2M=;;6NmDCedDF$fE)`&-YCDztadU@zL#%NRT_ewQwd#2cMo_o^W2i
zfyYkt`@6sGuMgiq@~Lm3amFlxcY;df4L+qR%i<EvBe-sQdr<6Oz-t(-YKCCDx_Yna
znjhoFOGjQtS$duczBt0&i`n*f^UYWcb(YbIHlJW8eG8Mqo~6zGqQoOE*C2q9+5<1U
zbu0qt?+OENR8F7hT>1iuV(2vE5hAP-JW4&0q#p|e{R=;#i%!+8;&_{eyB2;T#~m3j
z{G3+y?i952&KUa(*)%+?5v5-T*`wt99%K3pF}@1VTEEyR<lWU#ezN3Q`ik&h1-$aV
z%-nzm12g&#_OBvBKw^Nw!X_e!p(VZ(DFY$kwc`Wi2RIr7-554E7TWx0DQ5>v0#SqF
z?cFzZ%Nko`*6EnU{la>Bk<(9P-*=F&C9oA_%x7qYEE2sh`FyjFGqas9r}ejiV5PkV
z&$T^Y`8V>`j?M}r&CTU$_*I2z+3QXC1Z&x>IyH17R|pc<f-}Rq1c0Mz#;3q+T%bh-
z{v~97p(|bgp>BT+tJZ_pV&x`L<u>4!hi{ljqINu*8b74bhAP-zCbH9a7X~BpJ^HrF
zsox^9`_T_Rim2=G!AFI+4!>9N$*02TrSl>z;&dh1b=tMfhC}L<>j`3)L7*YXpOm9R
z=?vM|n&u!+k#S0qJHgukZHTnL5QtU5xM4>y$_MKqX&C+dWMdingnfBNfjVN(5_PU{
zw@y8$IIqZ9U<5xu|N9TE$kL&`c3`ewYuZ8De1^S8&M!RrsxfuIq8nXLf9?r#V5btj
z{4VRwX9(p8>cAn<1FK@4{|oEX9$tSG#aF^MHjx1F&S-=h55G*WSUR!-8nE#^EbeH(
z_>*uJd05R6TgFnS4-@m)k%+o}DDLI}L=oEaVWFxPi$yM<SX_4uk6qpxlT3MpWF?;Y
z5%;3ejIHdo@$A~phS(7AU2xnS{FTsx7eLLXpVu+Yh&2g*L2i*F4q774`VrR$Se4y%
zJ;Rm9>>+-`o@J4^@&VT(R+ofSj<_?2)_4b;CtGBZjvLuhi-YTt4q~jP^<kO7v}(~J
zIb5jZw?!pGrpU0CkZ3r9`NEDCT*IJQQlKb%xyE5f9uCL7BK;?{0smeexqp*O>i<nH
z9i%cq)qg{aBEauEZc?-(Hpe%myg)k}Qys`5u@O=WNe5a%(&vy&*HC2(9;Y>;ff3{z
zj%OjHR8e%GzrfhD8^mEsrJTHX_LFDMlhfAYQx0JdSd?MF?%n99)@wof@oTpO{8?1_
zRjHI3!x~KSAYa3Yg<IWE*wj9>4NQ}b!|Gz-6};~@-D)*=LqFXw(nSc7hL-@dSDcs8
zQ6*oSz*c78!yc7-TJR0s>gYLjPS7bVk=*dldqv4qBh+jH0z!FfD92L2au{RS8Y~%Q
ztQt8PMp?|FcxF-t4dNngGpjm_^$n`ZIOQ0bUn2pF5CX>&F!T)ZuCd<2LUBZzi!UIc
z1inbnXHH*k^#&T{Ji@Yx8TMJH?mRxAE!3AHb2^&^e?G(91HD4NhJgQ*K9CVdxKs>X
zgt7TA1Zrb&-cKAMKH=`N=)A$BVNanD>6$r4P|V60fxrP(B#*e&=H0X@`)9ULI9;ow
zEvHf}%z=AGer^UO`;!I11}s57OB4a{UimyizWGEayr*5E(`s;eIw*bdSCt=>FQVMu
zNFpyubOIgTbWtC5o=mo75wr5`KIZ&`8HwTzYp@?8W8<cX;&l|!AA}I?EX~O)xXpqo
zQ4|s0sAE8T#%h){1}W8qm7TFCTSwMpr|#O6DLZ@0Qa$44@?2sciiB$FG2AIoF`{2G
zB-ijje4hrJ5@1})5!_<om|AWVIap(=2`#k)McxM(CJj<=T1~@`(BfkJC6sP>Jtey(
z;D|aA%!I_9w?piEhB(<xrCom~Y<JyB7Wl#H3jg6?h4K)JViEr8EG-EZ^^R-lE7hR~
z2}g7{v!uR<I2nM@NIpIDiS%iODF(yMkftD60m_!nZ#u_|?Vh3O=dE(RzrUg+Kra)X
ziZ4|l0IYF~y-`7<A4}R~=fCiXb4)Wey`ax)i<q?k*;ocj^A)PeToK*cl7_fRS4YNm
zJ4Fe$W&Y9sPx3{O*d#0eBrgs1zv%*sQUcg3kIRIDpBOg-7Lf8o9<Tk3NQhQj8B<J=
z=o?zTGGu8Pr^B5W1#ZxCM}3zPnJRxFuotc@)DMg>1Q7buOXPXy*wg;V)9mu{>l4EN
zdnMzuv+qZNH|BtjPQHBLg&<<!gW!QC5vDuyvSA8^WT#Nb264EEod}btqviMn^g0lt
znzkB749Bb!w&*FWrI}sqnC3A3QspC8H3F9BV3$0kRHY0xdV#8rgf-=pxVz)Vv;dc!
z6W(tc%y{PHxCqsQ5|jDlfIM2cA3Y>qk(qm>A?mzPLcU}}gEdDUe*4aN#(l#OzZ~%g
z!*iHK#5pT>ID=v<_X1#{TZ(RzJ_smX;mZ!ga$Wq*)q=6Kxw~Z=hw);2QYSIiark-s
zA}y)+SiR%P2=|MvR)pmsU3wg`$+&j=jL&`E-R~PujhjvJNldG+TM_EiFrkuZ-pp)$
zIZUGmG{V+F>x2=jfM;dxYdmyCkN}&3pH;hn;(baSs(j66-{0tEtS(-T_+N~0CFHlA
zso1m%yeD!pc75PcsdDlJ+r4vuZSU-QY8M5e!*BmZj+m3hC;uO4_DvAOPs~9lOWYxa
zPAq7`1iC8gD*O-eS!<tJS$?a?&8LypZf70*NB8(8_s~(np;h!oT-@7re}9bpZDtVv
z4E_A3&lZqivG-qXylN)%Ycxw(<uSkHa=u!9+dp2u0$Va<^x@@Mx9^<S-r&W|F0wx}
z)2=xyzJiW9h~M`Hoofd=kQMIa<&J+xMglgFOw8AwgI>)t#uZf`{;=y10OTuY*H%h1
z&ZjAVu~k1`R3||O<J&EqQu40f1S`gvqpzV;7q-CKSMupv15!>-uUHHaS0Q>TWN*ge
z1ADKNbsI2S3QN=G%52}N$N8*7lO9{)L$tP#_R^8_H8`S4`zPS8Zqg63b=PgPV1X>s
zB!h7~V`h|p-@EaYn*qw7f`Ng@F~_0|0Cnko&wa_4I1`ye5u{~Dl1NrNs}Tb)oMpxW
zBAzIC#IzAYX26m3p%kVpwm5XlC-p~p-nxk-z!5XVKC85!Q6R7JHXZ~;Yvu^!jveu}
z)$^Bo4vjkc?JEzN+aqoejUWMz7YJ)XKk_P7W;`S5BhybpJB${~HetvgqYeN(sF_LH
z&5JS~>}@}`pEn14^=m8V%0m}f(wD@=W))BpzOf4e77J&)rAx#}Exxr$H+Y6`oI%|#
zB24&wgU0Z(PihS%6%#CQit))?8SX;Xcm@@j9kwcV2K&XV@@L;Gy$0{W{;Yn71CrB=
zBtK&KhSD%mQr!HniPC9tNB#cK=pz3|g7awwflB}9bP6IF2r4Qlud_Uw?^4O8P?(h9
z1K&i8q)~qc{(q;(bY@7xCL`}Ma1uTIfw?cB9wJhVBOXlnFguFgUSR=#eRx9pBR%)+
zTs}TFy6#Kp=;XzG*y_7{6f?-KrA8djo&02DQr^fH&L)cI%ZADi-J`}W1g7<D9#Z!g
zZz}{QJwcqZ=2um@*40V1H9t7@@F+%rYsSKyALPpyiZ?1#VBqIZmi`#jwiZ~@5{eS}
zdZJ~7PL9FW2oNX|hL$r<WUS*=2f&l{LnIdK4BIMm@3M<@ydq|09-jz>3tc22dzQA!
z_wApciCqe%33>jqO1omB1TNto-!UQ(Qtt?b2$g+SIO+vpn=dQ-;S))%zPDa+_ZqZq
zeby|GZtlC|U?G-^_l$S^j^o%h^FDLWhT8VA3hm9Dl@RYqTFbdFJng$8vlj1>;#y#G
z-SZzBGU$bhfwl~OjFNzt*)HWGXjOwg;+8mO_RN9B-ko@Y`Q72}!#g>9XZ%WIXej#&
zf6~CTQivVtjD+@&g+bwg11f)PeTp89ss#T<Ja?KHH-e%M_<yE<P5TXB_0RNE|Czpp
z-U#TAN&`SAWx~PzNAAPI+cvvs5#DAuHuH!6kK7j;>>(5W31yz56T>C7d~RTIH=9ah
zaen%I{n)4Q_nct%;pg;F`Yip`)<glWt-nxZ+f}Nar|-;1&|zrsoJU7VA41_lO4-&=
z(!Ykfq^J5s;_H~<9Zz}2Hhk?l>3|88a5XfXO7D?rs`m-puJ$H?%Ez~xm{o#|!G$H-
z{F8Um9f$gm@6qN`qRMVlR|7ozW;{|E>S`H2TulME44q@bAGKBZopPK`lXrFZry6D6
znVy8GL?6mq=$T%lg6ed*?&0?^@jr+ANIYY=+JRIHbwJ8RBtp0@;Y7Vf{ft13)x)=q
zdyk#p=XL47m3@~4XoLLH+eVFBZqN(g0&rVzM4;o}a_U%mUj~jj010g+FGxrqt-pnE
zG?B3HABaPUkZ|ZJ?L|e9y^=YGX0F1X;bK#YRG!38=AYZ%e}we=Q<`>CZw-%I5jM2F
zdt#-*K~R@@692#<XNu2@`IQ0O1#S{#)g?P~q@OhovAW=di^sngx(+ZpZL||~WVg|h
zeJMH?cu4iL+CA<;+c6<#DaDD)e~>iGL0;@Fmv{6<q~2=d!2cfo8B44?1m8sh`bK8d
zbond9XS5>w4_+0qTn$%1Wjn%c{aJQ;ie0!3d?5hho^IAMVoIvMKV;IHBm4@G$u;0`
zgHkX=G}QA=Zi7t6PVFht)TARpU#pGgx5Z(7l}@=su(iJSDV2`BjC+>6!l&3a$sjzR
z`pSll!M$b>2Ajj%1!~kXQWOnX&}vd#uA_yM5w2ArnluU;@P7<a-$|OxB@xJ^4%F2~
zm%#8FhU6G%lvK5$J!4-)11EyQKz+A}(x8g_DP$`u6S_&Hx$<{t6G^&C@A<xcdcR2T
zacI3+EBB%7!qwhuHfQEb$=j^|*UR;(-ruQA&*KTME3Ugs!msyR96@9&#AyP)^b;UT
z&hA=g?ftW$PDZr*5L<^bo9rcaGcdV)rTu3IiEOW~P^9T)abx|=(Wcg5H1dSgJZ9F7
z6_wiVViJ+>#QlS-HD3wb`F+hrPE{H?_6D<p>%6K4SwC7IQze=vR`C9urpeXS*~OW{
zsS(j9BjgYY{R*1|`Y%M4e>Go4Iu)-vgSaY9oZI>r^~RjU=sc&p&MqY^Gw^TDKEgll
zUXe64JpnhVQk%Lf=;!0anUgVPIs_^nW=TvGLFWRklp<Gqg3{bXr8X2|ou|=b*d%%6
z9a4Ry(Kg0G<L0t?EVbH*a&C()dRnv|%n*Hcx6a8OhfI3O1g(~9Pu1FYDZbNV%TJ7d
z`OGyy?g2z`7Cop!=#Qa!z}&Pv&kSTJm_E+1BUoaO5>zA$L)ff>h4b&}?97wt7?ptl
zkw|)-epD|ry63>*uJm(4cbdSbS)3tMyy%}%zH^6;prwI}Nd4_<{*mA6RksdSzDeob
zi8jc)5TO2!nZg|r=%Oup)m&907m`A5j-ZPUWxQS~AB-WmMllp&U;$!r)=637xC1#;
zQ)0`eckUG9O}9b=T`X=25AhG|@3!B|w@`x;!ZF%O+bqj1se>=SSmi%hp}H0Vs)zBX
zyDU8p>AIJMiS<inv4*HJiI}N33f6ZS@9l=n#y6<KI@k;?jbNmQ&N9Lh8US%gh?jp}
zs3m(}9*j3&>Bj=~fPW|uZ=&}>aw<u!X^zrO5w)FpZ|T>gN)F+M)Z=vHkE+$@R#`Sp
z7lrG^PQMP9(!~-*#&uMGwW+pg(m9{Ow>PAhD{<=-P`A5KEH<lVe5Ki)!|yUDJ1n_T
z@`D<9X4slU*qRH7TLTryihj8hZT4{Ggv1ZR_W${skTiOC0+v6OW-{BsdqnMe_|20C
zv8ToCyylljYM#+#3BI(HEBGaESX;{-{G!|E^ogf84FK$3mhPgFP@s1lU)d)xj(u|5
z1v7<bkP?SiRXl7&8p`?)NY*U}n^wSL2H(5jy5qpT46^&?nL_C&<N{PBE>{=o>B1-T
z5Np;(M-dwtft-?G`RmJ=6Uu;l?UC>|JxJ5WOA$C|kr`r${$A0y$4rvnp;V5T%EeaE
z1|K{d^DR$f?KHS*p2=5p@tUujam-`o2Uf}0yRy=|;vC_T!UA1Cjg+nZKbWZeO)OK^
zr1e4WAD;f=g`@XwmTnU{5VIzZ*t5SlHSjct@(vU@f$tCp=zZSjEBh<^#>k?$DGs#H
z&rk~%K2YIUl1se`GXYa-*ZLTW5WcBAdO65CoNKT6-O_G&7uc}f1G^dyaD)Q=O&W}A
z4Z)x0l3!tktl8SaM^rdHaJ9$wpFSZrOwTk)dy+qY(29m8&;ay?PVBY+w(0)e$9)Vp
za;!9l63<~UJ|inm{VC4lH-y)(f+sZ>*7)q6Ii_S#HbutCk<;_iap#@G6uV_O_Nt8|
zaMOSsXNnB|^}phoM>6wP2MGpd4Ew)XCzlC5F{TAI5s?EGxbB9o2KaPKbelWXu*g*u
zBo&oj$HQ5l!|?)J*MdxMluW`Y4IQ13=e{r@pOS4iXft^M>-O&iYiU)t{X?5f!=Tgc
zpV}Svu+1fCRKK7z@p+tcC2(=I&eQYpus;n}Y{<;(`TlHoTj3zT_}E$$dfczYkB4CG
zR%i0N+<ZkH*lBT|`Tm`w?ab-5wV>V6Hq_eNuI&VLd{=&YtI?_&hP9}?fx_kF?5whO
zPivTE!osi5F6Y$BW91W}*QUluJB8m*9p|3IL%&E2baFCd#$JB$dp-vP1ZCEZ#|+s6
z$jxC_<%yIWR5uUcCRx$kRfi8>%XMkXQ?m1Y(B2V&!|sc|Y=-6PM0IKFhv^h~vAe%@
z(e_(uVwtl`#~g^&AX51HWj9nevl_Lu3;?uT8;2<^nxXD}%p2&8p;#Bb)jfeox1reu
z^gJO>@%f`n8)z+mInN4`b|Xf*#rl~$tr1IxI!v-#hj(yuT1$2SAQMSgW<=L}s@=jU
zLr6>@<ji)gUgo8s5;L5+NhT&GHU#)XF?f+(mzcAwrGl{JkQnL>G&IzuEy#b@QR2Zy
z!i9Hs?zRd96zZj<kCZk>?47zoBL|QwPeR)&*|xvI=Z7KvYhQ!5%i9##om)^O($GC5
zc8a-2?en_i1B0<a<6mU)<ZkLinJYSNfAoRQd>iZriRe&LI?0YuceZ=w=aPNIld9D7
zu%kCqaNK;l!=0e>z?mmN62o}&a4OwLv#kc=d=;_gR9hj_q;`{B;$G=-v&{oY(x~L?
zRGSL7cq%;n$+R-OET{&RE!~McD+?LgLB(MO9RbQABdI(^+J%a7V3?=E<%b<co+VIO
zGLjn?(T3Kar;upcF1y_=8+R0ALrgr_r_cbZf|)9Is#kV@WGYmAQ=|05XVLc}RPh=7
zIT&YpU0#VyyxPt3y|+i@w!GlY<EJs)dQ$ZkOux~x?=vuhM9YViP1yn~*=2D6OEHAp
z332yFbJ$Cu75kInMcxo@AbGa<SrJg!xZqM_q`oU|>TbcGA6rl_tV8ChDbh>=I#fu)
zG5OL;cJ@-{{%dDAu2pXY2MtToRt<+n7nu!mvw~B8n$PPkCEv^PgB)kntc8YCY0!aP
zt+(t18Bn%YSvwu?+dbH=I4EWqI@;|LcB6U^MULIwkA^*u$lzEM(Pq;g=nh1#6ZDVv
zz<0QpAl(wAoqR)PbQ&V$8Ms}VFA(SneSSb7V&fiHF5%ajkEdR$KgZm-X6XJy2Xd)Y
zvOCkMOrv{%bRuo_3!9`%Cwb0e%->Vu@QqZ6^^3*Z+c$4w77=cXW=3G`&RK#S#NT;$
zwy7fAL8B{!(8(p+d_ph$`=|(FNVt(;>8g`u#0ADEWQ6ngA4iKeB$b9Pg~K9=H#Ma;
z!kqWybKF+KXFo);o_AZ2YlJEKKy~yiDA%sV@m+uXk006`3AOV6OEA0tx2hfC;Q>xc
z_Y0zYE|r%xeKwvgihR#ELR3pq7DMTc42cNbaqLJdw&svpm4hdK6!JkpCZ>D_<4@wG
z^SEQ4cxu?5`1>?HjO7neiO?A}%rQyPL$l~VH)8)%eth*pEdyE`(J{A-GeKptAB}Sv
zFw$=qe2_xYiRbKDOdOic7KjQG{SJiS8$BT)<XGrM^|rmc@~vS6!7Zl>1rZh1$%j|U
z8=Fa(;7=QMw*gzX5s7hLrcGf3#%$F!#8TJd{-~SnGd43bV^A0LTU+9bVQD6euv$6m
znR9Bc_E-Kn3&I<n8Dag-vk9Zz7U~)B63+_76%hTX%HU+%=WKmwtljY*jAU5Cz4(&$
zkM<u|N5KD}xmLu~cpJVlYzxFxt)MhE{N`K=H=%dkWx;s;91CTIZo3vPg|o~io<Zpd
zv*3QUU3VXz{8r&!dD)%!2`{@zR?R~B@xN5AViBXP@^22R{J$%^9CYNwixwuJtBSVs
zyg0@uJA1s*L{WYrmR*FFB(YJMlr*DMYx;~Z9|q%0z-@iXa=jpyyL(og;mB7hQ1ESS
zx0jL8cKfXW5HrBIn_wkAcj-R$GUfi5`Em6y4g{mk9cA2DYgYsAHF{o47UG+)!nIFj
zqMJwwM6|`!H>Q~23$<d@?MMUT>W0<mPQrKMaY)BBFK;!%xk?C^(6(yCxFozSE%`M#
z#k%W1>AQKtjKNi7myaxI<`|_z;*@aE+UX1Pb%K|>#A@`;!(5Nc;D!_}O(C$uXq0FH
zR%wVIinsE#@05$e#k`LlCb#wun;mqXQ~mqm^zxDrrl1ex7w#wHY!L8s`XZEg26_m)
zJi=X!z&VRzz}u*}?P6)Jtu%R6ArE<F%LtkpQM_;|p?k}Oa&ls;CO?7?^Y4%z^ijr&
zf*9pwk$R74`>=yUi3x`3t{}k!mlz)-(<tMSCwaFCV-W2kuQX<V-jgvdAHDWoOMoPV
z5~EMF2v@)1+|AEeK51ax!UC~9=A-r}RlOI1=`-ku-=$lppyVlQksdpf45sOr%&CQJ
z=6mglT#=Yj?ocfc#w%#zRrqX@+DBG(XSc(B3j%-8j|IVl7Litw&Rq*p{myt@8gqMp
z0rE$kXcV`#8Llw9#YD6BZTHi6zOwun7Ej&rLN5|&o>dTY-57Akrb92<81?o!9}y;8
z@?mXX@cwR=-65togTK1?LUPrz*w*ei$j}-4KHt?av0<Z;#q!Bg_3yjjNh>{LlsikB
z!=!^*sNUz=yT^gsk}q7e&XZ}rcJ!QN&RfoGtM(w~yJD~B`-r05jIGhia^bkMZ(L(Y
z=j3`FrGg<A;sFr3A5zu}yL$E#xo`NS=P;($KI~5uKkn`h%9HMSq><x%Q#a1;2+BUt
zXsszGdIz!YOl$kcPQG;(CCYM>8NA6@Q`p(a)$hh5J%dkd`Pf>cEIONxjUK(-_paM*
z#!EICyYY69Td1Y%{j;8s>YNiEDKCpL3)NvseYh4yaScoZvig|3d+7g2!7>|T`L};(
zBbooV%YYS804ny%uM491YNN>tD@*42_<IMy8i$lqf(HjHdQ+FLN#A#F$!3zByEa-&
z{QQS?1!h<%AYo$go=eM(Bg<hP84EnGCNow&U!A|e46ty)d#Y=CkZSrw%c)kCS_#V?
zTk*?zGb~9EveqfbB?ekaMCQ;F(N9U(h}a%XkNQ9AfUMcg{hBzYPCrh^NLJTzOE-}#
zUHgF_`*Q&3cTsT&`qAPwG%i~e@#6#DX(ON3J3n(kv<1PZP9TZ}a9XD1B$1ueA+Cc}
zJ_`>!qKR%q({hhVrEYXFscJ74Yb;4``W$3jH1eimX(~-GC}QxSGi7Q+O4CDnTo?fs
z2_6{=Tszy7G%$2NuM8q<T!WqYabkMQoQIz1{i<a}JyG;$=;(M&^w?2uWMHOu2|H5%
z&o?~;Ry8%Z+K44)^%-=Hw;sqEnTE5mZ%dFk6h735GY6-O-cU+({Wo;K_@)A#8-S6A
z8Co;KFq`JDn=D;(K+zUpC<l1Y?6YIPL6Dg4k4lzN{Yqb~&;MnxNnln`=)VjG@gK=C
zkd_51{U5a@2^p-Xh8?^@UP=wztTrG;V(T`Lm1V@iVfD?Fw{L-HXvkPy?FPIMeZpr;
z6NlH3e^Tz#La|xwktUAvIZyFDP56A>9MbqBRWkbU^KRJsB6{iI#a+T^2LK?W1q-Ff
zF<Y1y4HF(mcR?68nHz_3$9aGR&XGtUDRMKk&fx-VJ*TY4kFk0QduL}|8(wFfdG2Lo
z_#(VGWY5-1>AAWEQSq~tJQC)%J138dm&R52H&%H5$v`Gm9!o>Wu7n7HR#|w#%5`^s
zX|1xDvNm&i#Yxbvrub3OL{)rOKAz8X>4j>?RLovpA7jt71h2Br@a*~)KioOc5M-z+
zD~VNzsBp$p0-h#b<n4Xj(rG;2wqAiQnHc@(rr(17E?|wU21+|tmU#=zQ~wJ6>_R5|
zRsOqQ4K&WQ8soh@0Hs@A^C|bl6dRJ@^RaPi!-_03wUgSJ7#{~gwdH8+ORK=j0U-Dg
zm^l?}DKFh+?{AdTMSQY*KoC;$-5BgjaLLK5zvynM547~4OdSu<Y{4dIFAs+=-oVZ@
zs9yKIdj>2IX}p65(HGjSqnYdo_NM^IF*p+DX9>P=DgyuG@<VD$M}7YSTkv0CYh=ZN
zY(sHaQakMqwInsaz7yA@4SXY&|93F7=ik~meDT29&`^<9$My4;$Oi(8{-@&(#51Mn
z`nPXrsg|y;YOa$LPlWnC-#CYKLy%Kb8DOsFP)`xu_U~C26B{$m$}6LbET~hH7k@)N
z*`$GwJ4h4Ft1Mv|>VfWEgxMW9sv;{3f!r)Iv9qI6`h)@))r9X$3P(%uD8)$+MW(+1
z!+)b`Aa!ez>t(Kmu7vF4qCMlg?FFe=Ll-x!{mf`-T&VRALQ3im->XX6&2j|F$^rST
z)1$41q=c*6R}>n*R<dUUon)#<^rOrwjRWOEf-tSheNInHb-W_Ug+vVR;vLEPf$AF8
z?s`o#1JUGYjV6Lx&iI&@P19dXIayz;Oi|<OnXY;?czPidw3Au9$<tmE_FgQvNH$;S
z=h6uVzlf-);MpkuwtShd_1XUAs0)P%c__IpJ~0;QqtZ$3=_FU18}pQC$1jsU8=A%1
zc!#Xa)n0jJ+d_X$UnuP8xWf)5#P|i-6lijd{$El&YrW@>`4=04|6&6xf}9v@2%C7N
z2AkL~&jeJmpI68DyqsI8a+HzArBsbuETDyx6F~^B3_wx`C7~^q35ms%*WtbmIi9cV
zuF1!vbY2hjXL}eTukUBaFDcv34WTDCf3aTZKon$vO{Vz#Gh@dw&#_N8@crSg1}x>8
ztKS`&pz_yMnysBJ+%|ivT!ryehWgBT2SMz{A0Wd6xVEAWyu!8Oj9F?ZSp`jH72{>d
zkyEI5-fxaK`Lf|RvR{W5zo;XZ<~;kx&d%?$R_-WK+&nGgQ~KO>^kGk5zl*^Lg9gNI
z&iYnEtVVx8+<n3Vg0>KiEW@q;;Z~~vm$8_GW{R=(gr_&*lp5&uZY+nl1GU-RI;<`|
zAdn0~B7)K8UvPbh*btda*kAlp`7U`5n;wg6iIMsd`}KA>g_$Q<w}fXT*{u;t*rWgK
zqGCFo+Wz^{hAZNpOEuboc6>$_S4{L9_;aQ@Ew=1lpnxrZu&ttK7(|rJU;_Y1h=+pU
zAV>iCVmOJ=E_jN1Oa1{&hxmpgYc(tBK-Abhhawqg6m}8ro_4JjK=+35En`#<_B;}S
zD;pj~IYCcF?t@pJ-Oo^D*UUea5gpwDv3k`CpVkADlA{&77(whidbCU2s-oR`7VlUp
zEO8P-!^4!!c)sS-I7gP;)O#wc=C^ORiY)b1mjit*qP7CP$&i!l**_DYl3bG<fFQ|R
znkykXss&Auu|3Lp9bp^a&7iK#{bJXQL$;w85RRjRc|~5i6XP&22ELs1v=24~32%@o
z%cXUMF)h<E$jR4MpL@>RBIFXjzZY6Jnqgm0dnALJ@W*MU_*fxh9x1uKFkGgE*logx
zU>PXrzDu?O4@3zr`$Jn_pg(UO$n)EXhck1n_kLb<4^C~8<~j#ZjOFng*Y};To9Z*T
zzo#I1mgVtp!A5}rJd5^rvE5bgM!$~ulbySE@;$mL97mSim%kHJ204&AW2^sEm)7iv
z`t+F6biRYrJrWi;u=1d<Xo;D#o4D=N5SwEl+l#yi>n#)CRNeE(f{CMpH&RBSY#KXL
z7$JuW70vtGGFnH(!vOnf1#LejwO6K@Q|3F@nR}woD`BE#;phK)j96BF7wUgK#=-yf
z80N|%z;)$$MGW0gZ5h~Kr~|k-iu1zS-+G-;1Bmtf1HKvlz23o_6Ty{C^hyYfA|c#^
zd5(%nQ8L5JaT$tr+SuJ|9K;?KNoaUl^R8-`miGJjd_@uzFvH%uxS$){wm9EdL35MF
zosB}O`o)rIGu7B?&h18eUI;l@R14`2MaHrb4Fq5t+O)k?Rz%x4jAM3b(c_Qa>I~d_
zS0W=lV1EP!C*RD!Mt7Pj{h7R$B%}+;Vz(tKv@D@&rz@1v!HAWB$-j}5wz0MkGC&-w
zPfP{<W}@pwaW&yiN#QjOUx_(r%Z#hDG#_rp%RbXfnmXSc?My{&Hpkg;HUU#Zw9W9z
z01n&i4vsmoA<A7=pNG?`DN{^i(2MMEpz>d(soP{9i(^|2$*$iIVQbyj>sTb`DI-^v
zE9O$e=IV)|G&PlqlZZ%Yc|>lwy5pr$=NH>DyPW2=^|XH?5g(DC)spHRhR6iwTpd|}
zdpR18g4$)`3aIIG7nfb)^WJzdzcsR`0vYJ(IwhGm_!*>N=$H4<s*}QsSadbh3l!@#
zB2YeYs^9Xtu^0Aa!8owb-UFnDoe_tPEcob}TeD*5yt`FOg|ON&Em{X>^s=+YGSsDK
zMz@r53$o>>+{3br!cNS!vo8FU6-W*5pXt0t{bn=mD=>eJ{LDubn&yJ8Xg#Ny1<npD
z>KjFZL67`s#KJLVy6Sr^X6!`UN{ovTLR{P>xSXFDQ-flhm~o)pU!W3-;~B9+25^5F
z7l0AWneb7>?>Z?<caJL;g)X5{lQR_=K*FUT2n;o(a6UeeK%xIunvMGLwUe#r8OU#O
zA3q9lk8YSmG(E2k)kRZU@W!Im1e|RT%$DZ#^ao{6TfBmOSv~S(89XY6NPCSre6uBV
zeBfj68wIz+7y;(YxWMwQ-ra)bffLg)wPVhFLEXUn3`;tF!hre@bL*IA{wgdqMokkK
z5ldmrcLjTQ67v6<{~)3J8`cG${C{haH{8?XqklV9RH*-dn3f19hLO0U#su`iQ^Wr1
zG2!6Zv?E$=4k&7jA<AoWn_p)Q5Kh!1f+5N%q^DaNy&N}7-%K+#V~0uh`l;t1Awj36
z)JYw&2D`~Bnrmf=i7a{}DmM7WuXvO1XK%)_NoxI9;cnc%=cW6pd*65YZOeFC;F;0i
zm2=$TV5c{G2m%vA+U2)(T?DW=;>1AAS4>r*cp=!Rto?`V8I!zA5JjtzlNO%xgn>(#
zMChc;T%`q$DjIoBjpSgE6d9&!NK}Aa#*+B5ZDE(VaSV_#OA@6QPdU&U?odl-k&{D}
zPJRK^?ssA2Np#*r-jG35tm+1B0Fy_**IL*uzEvPg<xI4P$cCa3+!m10in0uY1E=}4
zKuh?S5kV_J`iX`_T10qu4{7=P-(#imAT&@yFhQ(y&@&G_>`5(FMmU%0iDOWPS*Vqk
z4m#qmA4VgVl^a7a$u50kyPM7{A(GCS-HDCDQ7L0`AOs#8-1(GrixXAl##8WU?Sgiu
zjSBL%>}G%lZoin4E(x$kW7iY>to)8NQ`@3?l;lczf=I$+l{X*8&uJ91yjV*c5K&?M
z>Z<`d)T0&S>aQ2B=li!6+)Fo&3gyDqP|vD~lAPq%3B=TcbfD@_(3BylB-UHp0~wtj
z%-w2s+G=vc#ohD`dVHe>yx%SJm6}{D9=YByjW@q~5z-Hz4FXGr*@9#mM#r7%@0k5b
zm-FTSR+wvWk3S`^4~Fx?#tZCiSRL>4SE733)~47r-`A4eI#=t2N;@qZ2VoJ|6m|`4
z)sW6@gko`l<BX0Z!I~LA_#_^wz^`ovo1rGt0G8Ak;@Y70w$$etXlb5=`trpb_N@qg
zG>E&k0O?<`g}_Gx-2U>A3CCN@P^|U3c^HNt2vxTHI{pZQzj*qKlGcN)cx@dL_}RPJ
zY>|}g%9J{`pJ%8NW~1rhTgwn{`9+%8)=CPMEl<uZ$6shdnV)YRk-Y#vlw|uBN)j-V
z^iazfUnNPE+)s-S`|Uy>jY5~IaOL&li<XUJHC8ipm4KB*gnD~_w~hy1+gUj%H8Dat
z|J42t<3S|LE)04`aXwk7Q(nA7KlY)t{ld-Ie`{6bA8;6Ld&p+x;v8*>74ww#SPlA6
zMdHD*s$g23J4`bAtwX*nCCRuzZ{vCumlsP70hhg4;`wi(x@PT%*tefv6m>||8PB~L
zXIdmog$lgqPsBx=(A?~^ledfz)?rN>N5GKpWyT&{F^V$C^s0!nKceCMgQ7*beoUTw
z!pflnQ=UCvloiyy5gFtG^-!A@G-c?EsjETWQqLwzFe<aIscjojGgPIw5x5*DNcO{8
zNtTVf;|IX%=)jkMX|~)Nr_G-|fs=WS%Y@Qfav1o{{<kX?cisJtn=+TTdy7%J3)~=S
zXFPpQ8y=k{8!GzXml?w)#<FO*!JH9dFL)VqkEYoRm4^M`dT>~a3RbC|uE##lz)=65
zd4Y<-o~Z3w?qxqu7PvQ7(E9hb;EqvpKjU;WRM24vbLeH{(;flC<)1fz-DX!)Nkx@)
z$p+9oLD}<{y?u+#n|?Mvm}Uu&hB~X}qAWoXh)lxVhklGaWs)TA_d!;($RWU0S_EG*
zl8>luJv$vTqinAC;6AF)L9!190RB~%=ygq04wbHZlu22$BoO7@#TgN+hz-~8D$+ID
ztlj5(fP5^9#!v6`q_;a_tV(hW*+foxLICthfKTkSHpX`WFg-(>ZF+dhV5Gq~Y(&1r
zkD94VVn~I#+{odQX8trrVD`HH`Czh3n=zvJpwB$KC4R;q659EDs9#mf<j{>y`i_+B
zQL3ch-HDt1aCZ@^@FI<ZPQSYs1|4G*S^}Kv6_KB2$~9tlukE-zQ^`9$bI`Vsg9k_;
z`HUwroBacsVBG0P!c{L86>&LxKJt81ZJQwIl55)S$&~kUF!dU9?4x@NzgHYi-<7^7
z#ZhJ=^f2VTy<{+y;>I=pbK4+p5L7p#!HkNd*rZ{RVMMj$5z)fUQo?!MVlgIzT64&m
zE4GMXtkdUyo3UN_<Dl2Q3`*(lJP*ixP@J4aP)1Y3U&EtVc=vSEh_&6146qw<wNRpi
zf*((kP_woO=u?x^oTporEm3x9m?x8Hbo7!QS-y8y-u<BDKv*L`*i;rM77<MrWtFQT
zq{o?B;*=`-G%gu{ec;XNyleRT2X%~JhxDCTTQe{IfNQVDB5-Chu9&nfcpIn)j?Uch
z%ww*^lrMtz`O^&P?RNp%r>KHI8``JrlSJ~WqUqS8npwk#e&Q3=ZcUO>P<y;;B^S2Z
z&o2a%g$cYjj(1(sApwgRyP|;~_849nu0@Fu8z-1gyi0SuM|l(l2&P8)g*D7ftE+KG
z(ztUz61BnVGH}MvScY$kvb;dSRyQ0Ol8eMv%AjPG)~LJ!J9sukcS9CmNNo9hBDB-Y
zK5h^qyQ`cbOFy<`<sD_p!a5+H$2#Z%Tc_>qWL2eU_~)ku`*2ESJzJp;WkqH5-%XzI
zinADF>kr39d1LRwE<3aitJwYY<l)))-X?VRCt{cVcG@Sp;BXQ>wrHS(sN_g)PuA>~
zq&YN)&FD^%Ts308+$AD(hP2iB*)M3FZ|=D!XlHegmWUGXqia%y1a%>_#Vr9s1XK-q
zgyXgv@>e9^ei<Yqnd+GJQ+q`qP<Bf8+b`v29q@?PRzH4ge66C|P!;|6x-NBf#WG25
z-#}E6{ALW@<0AMX{up?=97(J?_hc1l>VdC!1#1d3DnSOxP&>F`7ReRPL#)gGS&X-J
zz#Ux<_AxTw%7V7R5#D0rP})cp)B%1FB7%)~$_-yeALQ;1HT{Q8NdM#W>F@Z?hr|wv
zruGNn#7@CyY!kxg_b&=^rd^6@IdNh+`Y%=J*k=LVca+QNomn7x%U9GNfh%HO<-cFT
zzr((96qqVNE1)c*!~L*#dh1E)<w)&#n!QCgAu7}F;n}$bYG3mwPmkBrYTLvlbAbxX
z32SPq5V(iTulwOBET%byw1XiI3RIrq?D~mt35GV=J7Jzy9RlBpcM2BlB4PQZx)lGE
zTsI=+^fs`&yz2wyp+wYVU(`ec=!Tpf>WuP}cS}~{kgg3qE=<~VO)?z5rkyYCu~rzI
zHA4URW%YAIJ+9*|k=1VJAY=%BaR#-^knJL%^|bsy0Hr`$zp13y|7_Uh|4Y~%43`94
zVNbvvmTJSLC3WFaPkq?`T%hCx{+X+)V)`vY@xK93O9u$yrQ<<n2?PKDDiV_ci!+m#
zVJLq=6g@*L-F~20QBYK5RVWGD4H!v-!~~_lLk*^-BtA9M-P`Tb{mSfa4KeaV{1?Uq
zjVAs8f0XgIXpG{6FEew_+;i`_cjnvo&tCzoV@crM>1ng}M(;{%K!L4q>Q+x*)veHv
zTu&x$7#MzN6Z48Zk}>gRU&e;jCu<O=eyo3Q_M{insvbFpFC)Vp<>+o~tXb=iIabwv
z>3gZ?F%kErvBr=B#|?;-8#v4kNyS`?`C9c+wPx5f)Zc0l0)<wXDvNeqj|7%O<(Q6=
zwnye`C8LOxxi^OGnACpgQzHxqX_P}&VER}NrRmAQF%P=OWF<LF3e4@)cemS(!_I$R
zb9<*z@3dR>W@rE4MO~oW_^oIqBWF(pv@OeX12=gpkg2R33C#W-^elBfn^X=Zfyu3L
zYzdc9EMN*(1oA0ctM=KOhO2+LYMsOh`8iw@C_0q9R3Z11oCqvcE;?DcNR@CMHwu`+
zEEgUPBd`UG|I+^S%qec-*2w5QcWPx;&qu4_4x=PI4;7fH{ImE1?v0d-C1}X!aS8VY
zvd{Ukvx^LJ{J{ig=ezMqLjgtJA2M3T1fPKUFPM7u5!2=JC(NDUcKI$ZXV5?3!FymV
z%kVmZ%nwjY2MDcD`jpuL006QAlL2K@f2COqd>m!9KWFwavy<&Bo0Kl4Wl3ARX|f3|
zkhWV=npfMjo3u0yW&5B^b|=Zw-JP&I+cv0p1uCG|3tkm1a=nURe4rq<n?QsjYC%O&
z)T=1Iy<WxF^@R#b@Bf?GO|r?R)Zgu|?d*KtIp;g?$2VVk_0h+PXpJ<$boY%nf9_iM
z`kFp1c1TahYr-|L{+jxln2{PvBsDW(q(dnqu46r;Cv`2WV{=f;hGK(y>`*qB%GQMY
zwPaSWuNfK$rL>_?LeS`IYFZsza~WVW>x%gOxnvRx*+DI|8n1eKAd%MfOd>si)x&xw
zi?gu4uHlk~b)mR^xaN%tF_YS3f8;VTeRCqIGc7kV1C0Y2EuPdHk7Tr=AwAQ$#d_Ui
zzjbMev`kK>`PXTOwZ^2D9%$Urcby(HWpXn)Q`l!(7~B_`-0v|36B}x;VwyL(+LqL^
zS(#KO-+*rJ%orw!fW>yhrco2DwP|GaST2(=ha0EEZ19qo=BQLbbD5T&e;rn)`Al<g
zP#ctGOU!h^j3Xv@LA;WDDlMQYrbV+s$+VEE0%Rjb%rYhvQzV+!&Boqc5fEBLewEIn
z^O?L;cVxPN$z>Y7yE<o}bpmZEU8vF$3Y4OC%2dPT!I?eqkrc$JDxyx+wwIRE3YC`8
z>tL0B7+0ZSiPda4nN~5mfA#Bg@G++9U}U;kH`MO+Qay!Ks-p(j%H||tGzyxHJ2i6<
zM!cBG0fyi|!BQcLGEIdCYisBdl~&WGOqDbDWoiOTreS;JgkAt5R)D>Z)>qJ43K#WK
z*pcaSCRz9rh<ItEE&dgtb$KG4FgH#UZ^A3R)IzN)HB+0d)}2~Le@~lU>JS8)X|qkV
zTTAI)+G?-CUhe%3*J+vM3T=l2Gz?`71c#Z>vkG;AuZ%vF)I?Bave3%9GUt}zq?{3V
z&`zQGE16cF8xc#K9>L^p+u?0-go3<u6|EOLdzb=K0zH;Yz@<|uEgg>_WdI?oXJm@P
zs6m_FK9%;;epp{ie<qD1z3D?~<4AhPkZ^c-4Z}mOp@Sa4T#L5>h5BGOn|LS(TA@KB
z1^<gfYsQcrC2PxOh{)_**{4Ax{WKuB89b{DHndFF!4_I(AeVv)b`KB1pB6->r67<@
zQp!Vz2yF573JoDBug@iPQ=tr2+7*HcE3(5`Q%{A2p%psJe>B%3lQR>^#z-QI>~|DG
z_2_261`HHDVmM&*2h2e|u<fd@Ku~WOXb6PbQ^R7nIW>G(OXl?228C|G32{9e%Onc=
zsVwIVZ=g2{K5s0>v2}V&CZi1_2LA=x)v|&YrWGaHEe3L=lw}aSiEdWu&2-C5U0O~M
zpQ2Hj-U8)Ke^S`0Wd|XyOt&Gc+g8oC4%@84Q6i;~UD^<idn>(7ILW`xAcSq1{tW_H
z3V};43Qpy=%}6HgWDX*C(mPbTgZ`b#A1n`J`|P_^x}DxFYEfhc*9DOGsB|m6m#OKs
zf?;{9-fv{=aPG<V74~Jin`uk%EKX}<Z<r1-L%9Whf9_G~ee@s2q-fc$)6_FspGa>1
z$)qI2n`vZ(R8tkySy+d9K1lag&<E&4MJgrxGTo1ChW4UcKWbXxjnEyTk5tfy>7%F<
zX=}N(o)o;tOCP5P1l%W>>R(e|_M^wtOmO}n{57Qw_vv`gm^%s{UN#wnolnujDm_G>
zW|Bf7e}zsmg<kWxmVO9W$VW1biU2rQoj;<|7(EKDghKnSX+BV=&}Z<H(o7WBtd|}a
z+|<!2l!k1sFI#Z$>R@NtZ2eh!Qb2zWnb$~{NW1qOOTcT2Y7?BIUmW`dIxST86w{i2
z9$%&}BAXT16@Jl@frJ+a&w-axF1}39sPrZJe+sAtugKOG^x537N}*?=(nLD0AKlRp
zFN5+rz4Uc@PUz|z!k0T|Q|Gq?$bX?pHPS7GG|tpo&U5}*Zofm%3vR!Q0%370n6-F)
z0oiLg>VhceaHsY}R>WW2OFytn+z*ke3mBmT0^!HS{?Ov5rHI*)$%ugasY*W+rL!Vt
zf22(`qS@{Gu$O)=8mc?!f0)jjE=p@Ik&KJ_`%4rb1i-IUdQr3{Zqa|IQA0yz#h--?
zB>gS@PLTLt<PX!ZH@)-+(a5|=e}u8nBOomn)$64{(?^76Ub3_fH4Y_p6TQP<ZS(#O
zoFp+@n1fdSfFWO@zY8n<12P)vZlll_e|YJP(C|YLg63OvistA@$Gt3xp5h^Pl(wW+
z>6F=3=v*e6s_6w`a%Y2=WmZ&nvqvZtioX0@ykkZ-m~1cDi>knLm|k~oI5N*eLWoQ&
z$b|xXCok~ue6B1u&ZPh{SE*bray2(AeBLZMQN#*kfT&{(5Tr1M2FFltdRtjYf77#;
z{gPbHOBtiZ9gNYUs+?A3#)#p@AuY)y3dz(8Dk?cLCoks}DlcP97juU)dKR8D(GN~9
z{-WS|ImophC>G;}QVazzTZ6^z91{5<+mRYFhrQeg|Kn=LOySHXZqU8F1`dXWOJ?NV
ziPE%&FB1@$8!ntuI?)geXh|#Je>;xG^n$h4F)g-P4WJMPQn{p=fQtw0)}uk;u*&O2
zz+G5?iW_=1kTy(!AJzj}de{a9WHY+*SqJ7`<bkc|dn1N%C^sZC29ZVW9h+NvBfAf7
z+11h>={VTi)3NK|)*W3PUT#5a$D6oyqH%5zjdO$5ICHx_V;1Z)4A(rTe-r?vZ{{r`
zHnxK7^fMLS1{;H{o<8j5hz*F@WkKQmDI*Q<U|JR|9m8fBJ@`rt7`%%qSVl3E4kk!!
zMHnTK=y<n%1z<=2)S$m`+L^V}{Lsr+@g9|X`D!$SWzLHj0|VlKy`t#swfWnx@;*Kw
zX5OQSK)B#Rk?xuqlS@q*e-edjkB+05{Y3-CeeimbW>%Kf$Mo!EpQ)=HV^lsj9KSz-
z>ROVIrXAI0!Q?WUosf8t6CR*rl382^sU3q@($L~EC(AoyIjS<FBbkdC{fLn{v^$Z~
z4UtZ`)5}AAy@w4(gLxi!Jq#&kTBR;Hi>&2(el|I$a*8oAtqGQsf7-UuhBCOFw(^b&
zbol)FWsp15Sra3v%&#w<U?v<+GY3UMPW4%i_QshmHO;}S6W^rrjf`>Xz*!kSi!sV>
zmhe(I=_Zxmz&E1>i6=yB*_X4M#ktdNg7_G}MVRGQ7^zX=+mQ}1xtg7JN9E<W+2sLq
z6(cKQj*_!lzuucke=seb<w9nH^qu?;p<s+tb4;V9r>(QI&?4}=tP2#z2<7N%zf9rx
zzynL~!MgNpRvXaU69c*^X2<O`Wf>(c?$=h&o~Fvv06*{JdsM!gF$KALcW(}@Q&<c>
zAlo`@3h!H3j^@5rFMp8l6-q!cb?1iS$oZfU+}A2<)&2Zoe?fDkSnbf=4>q<Y20GKG
zZY2oJKJK{1fyfjVxsUS$0teHMJJ@NFfxRA7`D6T$=$@VwzaADX6mr4*spf0dvZz@n
zMLst;4_oZqwPRaH+ir!&ra@ZwRQ#w7IS$Ah5<@ojWA@tP_L>d%guV7zM1p=amds@n
zhpkK7mRJlbf9%rI&?4ftd8+RvAYdk~CGE?#q!Bv=bv1U(iVppMjz8~#Q+|Qzg4qLZ
z`D&RlZDh_GOr@SyE+h)n%I=lThPD;HsPfbNCEF{kD;(61l99D=ufxyqS5%Vut1xOq
zGImJeufdwBLvf7pUVhHb`<Oo}66o?X=p>8`+K+G9f9n`J&Yz^XE0;ErC#SR#-@%O3
zX5^A_t2Kyaba-4~$hvC_#EaAd{YEAr)E*E92q=tkV;;C}>B}0)oT=NEeZjg^<nOEe
zyy!cWw3aqRR<;`KZC?Hn|5()KpSVc;nb*3>LHx}pic<&Fy$hApNZFROZbBJ@g_Jp>
z@Gn*Ve}$;Vs!-LSmQL#^6Bh-iT+7Dn)vRT+0ti(1YyOQu{Vmgyvx3Tuxk5HG!x2a+
z(#>q7#Xji%f&ZxT@A*$m8~z`DDl?{&1=gKHThhqtSBmSp<nUy6!0Fb87~QOP^{@Ol
zmH)yom&_Zx2Vpjp&c7p7WRto+B%*(t0DqOwf2jNq3A2kc1`qX05+NNtEjfx_QC2=#
z!sH?szT<c$88eRLmK4}Andnm_6@|Zyr?(o0iKL(niEk^`6pmqawJdp6X^zM)o+NUH
zI0AlNTN-g`EhUs=ih{Cl+BLZ}Pnr+6k`@$a%)(a(D>x#kQc$Dh6W76k!dHlhS6V2(
ze^e}!#3(W?oQfEJB+-dxZOV?gj++sK_7-?qEM1^V=Sxex)M5X+P{^{c^h3!k*jCU>
z7pYQ}gsEf>>V^n1+ji40tL#-AxLjHx42bchIx9Z<z`>51CG4Iboc%m0DAfvd3@b}v
zv4%oRoYZpZ*dW?+yTcduQlxreAz&6Vf6<E9Xw3_`NotT9g&r{F_{!Xb%hDPJqn`CW
zqDwai4M@7F4CQ?@C{H~rqxXwD(MFpB4!uljQmH~(TXJJj3MEVHkt7r8!^R;bp!H=&
z%-OG&ONKIOgLJtng(VD0u9%2LuXKe7h$?9lQ^#cLOo}gOx^+ixt2Izmb6{J`f383x
zU0j}8Is+?LWLGvQ66Pg0ax4n^G+xW-rwp&fIZ0}lI?y~wn^6o3{jj*VSEQ}tBVn1#
zsVTQB(l&Gf(sriC0DKR8#{);Sgb5%k`%l#BfM#W|fN5C8APnl5w%nrNi{BWrDgudY
zAZLGEQKTzz^rV(Bst!UI7|8?ne<dV@?_pYX_G?9igK?yo0}({MC^6DiO!bB88kijN
z><T5+IyvxKBN7h6c(t(&xeiNl%!`>+BCQ8v!rg{Yz$`Hf$t<u<%LMu}Mk)|9;(8xs
zD_Ux=xWhRMYx@Oj2Z}9bp=;<FPMg}%$*L<IEPm*<XmlHv&$sLSn~hvLe{SEnNm}u;
z#e$iF978r2pKeiu#q~{hF4d=Jb_*WpB65*zl~=?ZDfq{dPULwBzbc57g_W*6&C64D
zo)+inqG%*fD=TaB)OcKep>B*WdxSPHMMkJ{&p0(lyXx|^X_VUQBdh9)?_2P1TV<rO
zJ5RetsW(qo+kYeDv^Tnce}DHV9dMo`&Gi`7MWc?&SdX((@5xi5vhE}q#ntPvniZ>i
ziYqy+91$zg%3%OjzWyY=X^f7I)2-34bDVCEhECAi^YqS9x@(k<kJJ02VOPlS9HsX^
zLiaI+-G28Y^f9L6eA@34zdy<J1W1SFJe@es_xt6_ybzNXjMEr!e+BCJ$eCxb{#c%#
zI8J_`$xzPc{qn&)J)NhohFv3P9>D(Bto;VDKfgIo-)s_q)d2mr4O;DTUTgjOe4f51
zkd6T9`xa6_AUP*N{jz%!Z0E!Dqq}JlfPZ2EyGN*EoPHJ^rT;z^0vaI03Z(WcdHTh1
zsuHxs?;>yWLj~Gle~*CjSWq|nUE}m()bBZ1`Rh^oO`d+Ar$33kry+En{&JjrML}&g
zUj3pUFE58(t|p~g@k3p&-uvoFzpGktUMnQ6RxDA&ibYl_A!{@9au^_fB@6;1XHLOR
zS}C(Hi&J8=@>Kw66&QJD@w>_I1XJuBW3_vn?f~bbTv3_JfAicE?921QNo!MQiLHIS
zD9?+dP0BsAK+yB?l009uXXMOteoGX;?5I|RG_v#Bf~l?TPy3zGkT`N>WlZRa=k7Vd
zbz-66IQ979fX!i7Wen@lu-oEcweu$76ZXrc&JWRf!tL<p$n#n-gQyuHeVo@veY|0m
zFF$4f+$erNf6Q%reB3d{ojB_>Rg2JqNG{;`-H@L`KHfgY-Lve@vsPT7B0@716|Z$Z
z-Z{!WV;qGHV!`h!S>b)rZpc`9J))^79ey;7@-=zZjys+j=U6maKhDddqZ}XQffIbF
zYn)R657nRGEG#j`M-Gni4deWVXcr=HoNok4SKTPTe>pVDw*WrceS&Wj^l1|q_VHWu
z{Pt**e2;MKxqf%Gt#e^JAKy{jQz4T)LUa6XN40EOCKLskF@9&B?+PnEe(xB+KN|M<
z@$&<DzAw)o8Rw6|kDN_Po<CWwfTvH*U!LbrTka*}^#q(toKC+#XuDZh7WPw4@F)mD
zwN@TbfBmkoX9RA7l}E&i^zOQ_C*)WB9ziK22%X^1OwbaMA&5bzf|}<9pNfXnA~lcS
z6%kUZMPe)K{hqohgq|!VRQTzhpm~B%kMq;fh#!*ro%K-Zm-GCrm4%~SB2KO@gpVcP
zHjBj9C$O;{?auQz@21ruVNaTa$G5GN5*X*_f1?7o{-BS)Cqj>ZP{jM;DemSl!tAG2
z{Iisge|}6`>*BENm!G2E!s<fTyY8W_<NS-L6<;sbgM(k?`FEBh{W;qG6fH%hgT^cP
zyMUfPHYV{1soVW>_XsaUit2`a&pfn!ggt)wG<~NoFFD~p(1PRvhIRZaPhi})MXmEm
ze-%O?Aw+GxB}7gAxHKo)H7d=m&r6ljuG2KX{&D9ANUe9Q=^7yych#S!-Q!YKbbka8
z)p==Am-8`N5_Qz~j7dxLQeaeCHYTma$)Fy}ORKS45sf%}(j`4U=~Aq(!-|ZRRXvQi
zjeGJ^%cq3itmW;FI)JsU8k4pNmCazDf4ff=bqwS9q)y8?KhH}MpVTd^>?u+Cs!&l|
z6KH<*pikOqr$wK%YZ7(>z%vWLb^+m&cCQ+h_MDo+aXmPW7CD|K$-d&cg$&GVPEi#)
zhPjGYx|SBxatca)&Ig?*<!7b1bIf_#dOqX)u6Vku+>6~uiQKE)tF7l+ci4Jve{^rQ
zo}1mB?m;{w?j6>1xBD9F+2<a#o^N&^lUwmT=DyQ{f2aE{@swNTF6+5d?y;V|@__Zc
zPQFPz(Z}@TzXsZF^)~BCqMhWRz2qbvJx_w%G>p#YP3U>vfnMicQVHdhK1yDCfacJH
zG?$*GdGs93XO$LkB~?nFAfNOoe^p7Rs9JiG7CM&Dd5!=ra;zY~qn6HhG|^&58(rYo
zNlP4qwA7KN3mvymz;PR0<oE{FI9{S<P6sV_%Cy2ck6!1jq?OJf1)cR&>%5d!IoDF1
zvxVxNS5wG&fEt`JYIGi>i=Fq;YUc>8aXv_wIKNAmI$xs8oUc$5M((w)UFEdS6{7X7
ziz)2tqz$eebh#@<&91|=(KSq0xZX>fTn|!<yNX)fYpKnB7qz?ZrVjV>v{~LlTjaOX
zR{3kxDZfD5<Uc`I7}=pOi5&k2P)i30$5jABB^3Yw$|;ipMI4fTF@FtwTU8bR-=xiZ
zeSQ0AyLL<W)pZ+mZPRXpmJ!BabWAFxjCG@g4a;ltn!YW`E6K~cfgma(A_yX=+mJ7j
zilPE`X`zhqAp?ejQ$Rs<2o6y|MHCc~dCpC;rd>AI-!DDy+>i5h&;6fs_k8@|!vGeG
zl>*x?yKME6ORBq#;D1Il7OM7F2YagPtAlp5&x#n1WygF`J7m&$+>Dq;!lcPwBjF47
zn!$~UWHeFj?=d0?v%b17?28(GK8s~^H#aW|E^eZ=@g>>)J;_Lf1`@r7ZxOL(ENsP0
zGj7GgG`h)*CrB5KFKIZgVTmtfZmPaig%Hp>>|{J>uCyYiz<&%o9&QZBjZnmF?2j9L
zeP+C|HI{IUNMzn31qA|=HyE3Y#)uIMH=f<S!3;VIJOVT2XwtDFjX^sWOvdA8%xP?)
zZAN#*RG`wvO-5v1#10yf^R2$Lwux<Wn`JjLf095kuL)TRXN46PD9dtjt2@b&S{siX
z+!QmN#<i<kX@64*FC(ozRyY}#5fxa_mdBCKG;PUUO8Y%dua%g$ketuADdRn_TWZBD
zXPH2}W~|-$xU6|c5_!}%E;v_52}+Alh;khoiur4*4n6(l)iD7R`D?n4Ntn!EGX>l=
zysr$iH7KYOD4@_&{HD|_Xd8cq<ei@Dgo1ej6T+sm%75U4OrO@|?8dC8I*!4y8s?)$
zVCtyI4u^B@w4@aYnQ;ZR8tPcRLgLzus5#z(^l}pBLjwzIq)2lNVj%%v&7lhq-J4NG
zA{JpWYdemdZ?HG2XcABzJH1NB39O(FO9bZTJ;5<rWa#{C5a*?ppp2wI+3_thu;=SI
z8OwO~6n`?;O0X0i%hN-r2}~kqmv<-ZNYXJ^8BVW`6>0BI7pOdZN+|dQT}UGsG!vAO
z3n?eVHAl>#|L4UKHqXn@76uxMT`NAR;S8K9aO_cTQg9Yon_hT^9i;%A%?a6#RbybH
zV@tv@qY742<jgqT>+*wUuOcfQveh)AWWgG&Eq_7>&ZRrvV_1=7+&qioV1y}UO7kVm
zc?ht!^9d>P2vo41lCF;jB7_L#`BI4v`BUi9Z~-o)V+;`hJLE-o`WS<hJamjL5hIZx
z6=RZC4w4BbdiZvQ^9L>8WmaI3F}bML(Q7PjYVJrzb!=phHh^xa)?+g$n@+G-V0PYg
z&3{4+dl7@phu245n43v<LPtF91({wx3eGKdBtmISS`!MA0!3!D&)L#OJ1E9k59LZ8
zBM1AjS;Hn!))z%+gw>P8l9~nU#$&-H_%!RgG<zCS%JO*Jkm415M#JTd18yS}8h0ES
z5aL_)IeebiT|qf8))oa<(s@{pNnx}piGM1_SlgNzCp)gfmx}R4TulxgI<MdwN(!p4
z?dE1j$5*hd7}w%D0>_vf_$ub|zzr0~h#d}_q-c7+JJcp8N!yLMsfYsqb@F-zrw^r7
zRVWJ;RVu#8Fw(`avrWKzSV;<QrpS;=9k=lEZ{b#ocse0vEi4(A0vxN`aR(pzw|@z|
zbMr~ZceomCz+G8X&t!^%?-Hsz_VSLF*48X2evfhKZhW62N<D(rvt@<dAB)&Vs3p^Y
z2sGunI!A+_Kfn*!z8_IGCu0{|eQjL)50}jc9ixr+;eOuu<8;wT<L8dFohce?NXQ$b
zVwjk?NhrICAfo#4wIX{{bUcU=mVfdPd7IUGTC%6djGLj=rXlOq!*ovBxz<=;G6N^s
z=|{4)E@N=c5(SUtIVf33exl)VJRwlHcFjuP5*1Gh)Q&F9k#X2k^t6UYv4?T!;I_0$
znfae;*oB|b6(K31HtPIzJjWs1g`bn!V8l+)$S=4V*o9w`i!F9C5~_;XPJdMogG?3O
ziQXy#9m?4kDCzTLYBn(x{EFh9FnY|jal*1$HRIrDe9T|M%Nl---;68g*-L-Ka{gPs
zIlmJS4JuwG=g8%R9rKfsuVryY?p)IwxBJtr<{!8wnNFs3=y-#pupfUUo9#qHj5-h%
zf1;AknH9ImF^9nIn4@Ym$bY1_@U})Z>YZ$bOXCwKHmUxrfNO2X!D^K=M?2re-;3}!
zyf?NsO1TRDNd`G~o83><g5Ch52Ib1gYtRSymxlN8Z*s5SiiPa{go^)Aq^Kcw3@b)p
zJw4aAmR=*?VP2FpW5G0t{1+ed{sR=XZY!2Kb5+p8VA|*|3KX{_*?*o+xH+YI>D{4<
zLc*;RnwnIhkYijfjhG#?$X<DEMUiZKgvNlq?l8G6bWIe92_%zxi@3wZA=lN6@{@Ei
zNlfOIC3MRUnN~y@hrqC$m0TXEM{CtZxv0>@6fu>m37M92&FB*6bhEklPZwTM$(yE+
zDP$xxYB&x%KT{L4WPd+BKQTY13i|T&$XS7<dD3XzVRL@0VA5PI=8|kNj}<H#lP8ql
zbgdO}ECG1tb(J0(-%Y1SN!9{UtBD#>M`eUMAnLo4eU2`C1OPPJK=3mP014BnGB=yS
zq{BC;impV|O7Lqj!GJ)QO)O-!B-k<A&3@VIip8?M5Y%c{j(=)jos2nF)I5E2(Cm}V
zj%d<EGnc-ZS@bYNRk_8gs)wYJ26DHe%1V$uRrH**LRC~R<XnR){8=3`U^LN4FUTAn
zOUFP#&cw2u&an0DoQYEjwnlffX5(Xqa@J56U(iA?Yii~hPTP~wZZp1yBSg4VNKGF_
z7KM{b_&o*?)qgXT-eQu{OH5LFxdCv|`Z7$R7xxO{YH7cR=&ahn`t{y|9jK_=fob(S
zQ0d!&8Q#Jjm^Fks_ksUPP>s3ieTCaeCrNi-S383FfwtN~OiN+G2<ig0T|=ms?7|d|
zFKwoODV#WjrGuzU;nb~Ys!O3|D;j7|1^p@mDXbhuTYuoJL7Wq4-wn@zdt%-F=p-TQ
zQZP~ob=C#~>uEKunASds8U6y=<}Vz?tbpHBpF(fvAfkT7-K=_=i+obLTCQ$|R`2r`
zq;Qe9Fa>8DiidHrUmZXz^Optu>XW4Fz&l=b1eXW=+7LebaC5P{SufYii|@c}uUf7z
z4)`ZXqkoINnwP%5(0PR}1`fRH)%>bgeE?q;NPk=}uocJg*VhCdp^*4Bvi}<#5U<u%
zx^)QK$<1^uQn+mxcXkdOc$)0<3}PUKdwgDH827SagXG2lUhga~^4yN+yvmc<Q!iHq
z{E8H(aDY=7;^;n*mAKQdj!3Ou)vNh3N8wAaTz{CelFoqwGJ;)!^}OTJzz7~E3x}|~
z^r;~{GlXYT*y~qQc;2h}l>xMKz>2&)u&X|h^+@R|eUUsG#w#i8EB*aJx3cqUSLy50
z<2MgZ3BOX%td<wKE(|mm-6H(u>b8$NvnfEo8B*9iIf)=No(}j6_<&3QJdD5GkAI}_
zVSnjIDGs)0053?F3w>q6MSh9)5m6BE?8N(lfVZ$K;4TxMj)F3wb`&;yQlhxr)73E~
zCZ<FwWlc&<+lmCop`D}PSG+Vdqx7jR3fVJWh2k(GIJ<_#Y>MVyTCf{6UQd~r<5vrI
zLJ9bb++L-FqFs~{^XV*KX&=C3`c<-^V}IzQ!Z$4HQ=*ZAK%DAh>f4Pu-hynD3cJe0
zqH&2)Ut5<F$9Ky66C!d>yYJo+(H!8*FeFac#oy_pEfXioz5B|<Ntv^yc`T-<!%gBm
zaWb{;cT0K?HNH#-@qna{QPanC51y6uW$csmHSCx4O==&Qen_>KDAia^(g{?)n15D^
zIg(b36D2)atd=w?`oyc^6mgNbO46&vwUS;hwo7`m7?$)Qu~*W);(4(j5HE_CB)?z0
z#ng3;>qhqkv0Tz3(c;?fx>fQ_nZM0-r{tM3Kj0daJX7X}Tn|c~Df2sBk4T;=^N+cn
zkUUf7pK`q-d8W+obG;#Xrp&+XdVg2)OqqYr^?~G>GXJ5wQ1VQPcbB*;n3t4z0?gA1
zJU5_{fLGv50^m-#u?_|F<S(RmrUzFN2;Tq|cM+(51WhbQF@dZu!k8eUnCM!DNv<`R
z?79FYt{_TXVU)Qp#T55yl)EoLg*%9;?p{oDZ-m!vOFeE0^zQ!wP)i30P6?19!{rMA
z0RI(}0gGXOwXW8By76umJat{FC`H8^K@=20LGUu&PPftQfn-}R#6E~`;e`lZ_y9hX
zI9nAF8OY51`Q}eZ-alU70BmAj;IZGoXxzI^8QfCba(CUJ?bh5NiBhFyrjpo;k`}RU
zNRzb0n;mJrphLl}?MBw!ZA)#b=BA++$<$N1M{{R?rygu>Giw?@^X;zIEZC0p>fBNs
zs+h>AIApa)#`0OLH#W958eWTf?n4PepnREhO+ZIVlfZIfLO(RJrOCfDGEK?&C$Y_>
z)=S^{Fuzz4!va$`vL}5l<Iq2E-cXPgG0J{l<Ht$Fev_vIMkRjkzsEvbD%~}7M%K!Z
ziRsgSUzf`)zb#Xv`zlu1fxzO*UxWYf>XkrYW%bH|gUK?As5mHLYz!l)Iw)g2uVw^>
z5BZf)=cdR%GlXhRaaGM3&Vs|i1g~@4Eug>wRMxJqUof@)jOp4lW}kooS{PUqJ^@fm
z2M9!-I|6F~008F!002-+0|XQR2nYxO001GA5Je4>>x?gd33waFb$&wt1h|3@lA>hj
zu-BAmfjCGV5h+8q93HYw5uy}QM_|d8m%xHt3D{+J7m{e#O4`V2j<#tMr-_uta^2Q+
zTPKZL38bS$>J__n)1+zBq-Wa3ZrY|-n%;+_{BHn|APLH8qfZ}ZXXee!oA>_rzc+m4
zJD<KzMB7DwPSC}3=Z1GZ-a4wKPw8f+HPM>Rw#Hi1R(`_BX|7?J@w}DMF>dQQU2}9y
zj%!XlJ+7xuIfcB_n#gK7M~}5mjK%ZXMBLy#M!UMUrMK^dti7wUK3mA;FyM@9@onhp
z=9ppXx^0+a7(K1q4$i{(u8tiYyW$!Bbn6oV5`vU}5vyRQ_4|#SE@+))k9CgOS|+D=
zp0Txw3El1-FdbLR<^1FowCbdGTI<Yd=2+)}(UW@G^;5l|`kXa3rrUznCu^)v%E{e=
z0vYR!nX|NvppCTz`^(c1U8kQ-=L(K-TI$u4PV0`dUo$m%%DvT#4b#<aQ_FQ`A=sI-
z(x-5L;m*BFF30Be_ZX((?h*8G_!j!!Qo~x42Q_!R$8q%hXb#KUj|lRF+m8fk1+7xZ
zPmO|he;<1Lsac`b)EJ~7EpH$ntqD?q8u;tBAStwrzt+K>nq0Mc>(;G;#%f-$?9kmw
z=}g1w<ipB6>Dm#OQM0@K7K=BR+dhUV`*uu!cl&ah;|OXFw^!{Y2X_bQcDjSDpb83B
zAM2-9I7B~dIIbfN_E3;EQ=3AY=q^DmQncV2xz0W-mjm8_VaHElK@EC-!ktWFouH=5
ziBgisaA1U@3bj)VqB)H4VK|{N+<t8Sy@S+2oqQhb)jYRLk8Nvmdp~VgXa~D*nc?(*
z8#a`%?8zYQENR&Vt+fmw-4aeN436D=n_YA_uTKbCF<(bN-6P0vID7dbLE1xY%jjOZ
zPtc<eNRz7>2-(JHfiJCYX>+!y8B2Fm({k0cWxASSs+u_ov64=P?sTYo&rYDDXH?fx
zvxb>b^|M;q%}uJ?X5}V30@O1vluQ19_ER5Rk+tl+2Akd;UJQt1HEy_ADoA_jeuet!
z0YO{7M+Et4K+vY}8zNGM)1X58C@IM67?0@^Gy_2zq62KcgNW)S%~!UX1LIg~{{L&c
zVH^pxv&RS87h5Dqhv+b?!UT{rMg#O##tHOouVIW{%W|QnHnAUyjkuZ(R@l6M%}>V^
zI?kADpKlXW%QH2&OfWTY{0N_PLeRc9Mi3vb*?iSmEU7hC;l7%nHAo*ucCtc$edXLF
zXlD(Sys;Aj`;iBG;@fw21qcpYFGU<ZU9b&zvU5M^3yjxqjOiRCV+cH$TcX8GLws9}
zGs}Lcy$4KV&`E{H>6D<g)!Gezm=gsTTj*NePkCmC`O25@W+`OSM1>tNH*Xmdk{4fK
z0AKi6FGJC#f<g|RMl=;BGMWpW{g@gU;O)-RBx~{*#M3#;(S!5@oF5!|0^%8|FE#{A
z^#<wf^bVH&!HU*ZH|{MMxeRB8cPezAfzmi9F@V$}Gse4MI@fwoKU-RVvk0-X0sC%x
zk3v68@8wjEy1^X}(vQ#qj^Q805JSbp{WgUA7OyTVf=%8}KhC;*Ku~;X4=u6sL%i}S
zq!HJu=(;*wQ`MiKkFe}VIcvPFfXXOH7nx!E>0@j_)KD&L`tcGuKP_k_u+uZ@Sh<3$
zbA}GmGrYql`YBOYe}rLwZKP!xrdrur0ib3zAR%*So7rZjP$|`v$!nA9xOQ4sM|Is)
zT`iB$29KOE-0_Y!v(GZKhMia4am~e#u5PJbJTk5!5Jn35E$W1AVWB&zA{r<8tP)wo
z%Vg0}o(EZ}Ts5eMgW$E9nUDxFyhPP(s8$YB7)%~lUan?sD~~9DckP11Ea%9&uY)hv
zUwxUwb}pf|IT$VPqb9AAiAuw>G+8N86Ovlm%$~Fhhg1!#<%uJPW4P+L>rOa{&N2gb
zFd3Fh-nnA8lL@IrHd6K33HFYag|7^pP;EZ&_CU5|tx*P)T5w<<O-<vHxNfy*Om%c!
zIz=^Hhpm0u002RMaX*cUa}I061=BV1I%+X}g4g-!XBVXRdFg0Mq37s%lo=)Pp+u-b
zBo85|bFx@znXN$P1N#N~1jF)^LHc?61qH?2r$7+}^DzU=b4Sh0ILA`+DkZGwe8`w6
zRaaLOy2{+;*G-qRoS@LWVrj2g$m_QBE_9ft8J2%>-hNeoB7VAth{E$^zh&!tb9x@T
zA^<<jrORjNI_SpK&${J_g&{nfAAf~@mBoJzd1aB-d!go}pMC=xBXEb1?t=6Z2khtQ
zWf04f1vH2DAzR~Tj#erum;iqZ)uy9mW#IE(g6{gBs0m8`Hho^9SLk>6WYl=|`BSI?
zaM#~0G0T^KK!+74^cJ#Nj`srvw<<6EzM$Kx-86sp4;1<e`z18z*=m6@wEj?`FVi2P
za+C>hc2-blI9c0tmCMY}Qn=5b(4Vqv{|sKKb)cXA9B?~><OzfSCFiKWps(}K6TAw!
zNs&-wCddWpm*|%np?{4kvd=0Y=(wVg0&0N%miZZf@!;iH4$$8V5(u$>#9fzsZ29S1
zTr62*LHahw(?8R{AQudS8<=zg^lz2qD}8im+_uhWqYUr=fMT#sIo${8zZfe2N&j7)
ztPfNL^8Z2}6)v8;x|<$fDzHr5?L0g@AOmYTwm%3~HQmw+c~!W5LEVM>2|z;BF)jd7
zU&jQ0%D8~=0et;cR2&d~)H=6#Rr*B(V9$6xY#V}Z4=>PWem5wViJ&4Bv3x<oU9vK-
zO1NSroFrCN9%JP_{h|r#yVl|1WYtAWlSv%7TC^ylS*)4AEa?}w0isAvoaxNcBMpSQ
zVEx=2c3LOaD<UK|fCBJ%>eU=0-BSSJgLq4Ssb;S7t=xC1%@8T#c5w$=0*}ik;4@vw
zq3Am7=yuN-b_|MEpaRpI;Cvp9%i(}%s}RtlP5ojEwsLfL7&QhevV-Nsj0eq<1@D5y
zAlgMl5n&O9X|Vqp%RY4oNyRFF7sWtO#6?E~bm~N|z&YikXC=I0E*8Z$v7PtWfjy*u
zGFqlA5fnR1Q=q1`;U!~U>|&X_;mk34hKqYAO9h_TjRFso_sn|<BD8b{;vN7Wr8L97
zG_;V+OQZ1Qn?;Wz?i0OOU^rZP+IC?A)j?47gDEky*GK$s6%kHC&K<K6to;7f%|(CA
zSr`$U`}M3=$hnpN!3E24{(#uWb{w34|JRlO>qdUDA33j5IN=@U7M#9uTvV5J{l0zd
zjRWGKB8J3Uz+|(f(HYHAjk#NQ1jL9!uha9;i4YYO5J$mewtTo9vVtPTxqXvBInY?m
z4YD)~h~q$Ax!_EwZpqbZI3OP3;=4xaULDboazx{;=E*zl0g)CIxiwU0S+taYYlIHH
zMHZAe8xkWHvS<a9b0jLjo8CSv12SBhG)#S{kRR3UL%bDjLssy^+a7A<zfR$+k^eR&
z+aN7R>jw;0&`NOTN%Xcr-ivm9Bz1h6ny%66)ZjF=M6S}>=v4~EuG0F;5<U&Ifi{*F
zi3hNx9__Mdq)2xjEz*{Yq|8u%d~k~Hixz2HYVc*MpSt<2$TixLN>0<8uJ7@5d0V_2
zpQVkF7Vq{{!dIm33#3Ft_}G2)yjM)!d^I{4d6C{M=mM$U&yqhi=!uOq^+sms!NF^^
zFO?LLY1%(UAAuAQ;Js8WHnK=;BI0?Gj@F^p*@W>;sZ=u3l$xf8pzH;I3P<JncSf(#
zaaQnQ^dC(nU!s-K>)vOmA?n#aMPBi8^%0|sj#w@`5rIzhQ!tSbr|=trz3XA)gH(s7
zqlZqzSnr3GpT_7Etp6(f@@<&&Cgd6@O_{P$>oL!s`$Ftx@?LJr&QNaX8kwntH#$vk
zYg|R22_$?WFI((Ps;mBgX=;jxe4dv2B0W9@Ytx5X>gz7C*}oPKd5d(eNI!)2=dpg8
zp7eD2T72>A&r(Oc#kZr8Zl0T=_oWh8{A0N9vXFPx)*^lID7MGYhmW53!69FY@je$)
zLq+<@3s5PVD$*r5``M(QjgmT^@OmO6-sp%gHc}rSY5JLvw`8Gz=TflG&)tw(+<*mI
zXdUgu%{CxCbK8#JowN2@0SO=M^#R!H6?`{v`CUe5FJ?SwyCTwGaWuckZrbd*cS97n
z*}$HSL^o`QV`u2{Me=!GI9~_dUxVbO7s|jzu~fEkS2;SKy+&74sr^v1Sfo!g?rt#d
z&g0|P1t9ae)DZ7~4AaMp^qVvE1qqxlUZ9nHsoy&~b@Pi;bSxIXMqg&hucX*B)AZGl
zZ<_wNNMB2M8@&ts^)Xsm@z<+UH@_KAm7Vk&{!iU}$6y2}y>=s3q`$h%KQ|De3gWd_
zT4=Rw*ODsRR%(-Nn7U+pH|>$_UfL(yBps0LFddieaXJBi>k?^{mF+lLvMtd2WXr!S
z_d)uoY)gJo;16IEvvuH(Z&YlEF~4MtgVERw{mtdnP$YGQLX5QNiKcH()87Fhz);ga
z;3ro8{wMqZN=5qDvS|E7)4xm6|Cyb+fwKtysRw&ATYU!+B2TOXK$*G3l~^PtLwPV-
z6rR$Fz;;o8z>*(s7WJjAq^m9+Eguv+(JTTuX-2FlipGi#>xbCfU@qZdcZ!5pBz#h2
zErNo*n((t*0g$h<N5w`)JK~D}r#LReokg*^S=@D^C}LN{)}nZm{OvA^M8ek?hV%Cq
z#l2nLhVDQ^w-WNjBnpCvP<KZ36~+A*>CrXHnm|i`@X6!d0j(RK8a`Hw2l5S1eVl@8
zlos!kPhF(7@ijcCcL%PBB!<=~MKK)m$2=`T0Eu_#R=NXIH=h{{`4iqLa>{Mu8oi!s
z7Kf(A;TzGAKje#F5l5QETXFpg?7)M8D4Qw*a~?Z-8SK4tke9LDVAp2xFf0l}5RJ{^
z1U}<`@`|I)B2%(-WLk{fsNVS{3NYNyg}nR)ue=tyK_MEWlVVgDvV8=;&C^-g=a&0t
z>2a|ceQr0P|8{y#_POQ$^YjVX=a&1Qq|36;E%!Nkxz8>4U!u>;KDXTeI(<X-x#j-r
zC;++7E&9SE8o4i9?#D#8>~qWgw0KJDS&EAzCZPW<!0IDZCz9k5Y4n9;sXFp}7f?$F
z2r(jpOZg4}0C*ge0Yw~>Po6G+?M@Rx6o%iiz(OgOQb4evxPG;TWi3Y1P-9|9Oh_6v
z)?nn{bbHt?>_^!Tj4^T{T!k9N#2;RO7iBy{i;&QUo$Tz+nfE#GOwP=ozrTJ1Sc55W
ze021t`blp}YoGj<zM)&Y`igD^UdM4|>;%5y1uf!uNG{2Uc(N@c!)lX%wI3y3q;Kp>
zH=-52V;i3A7>>%(TwkwPYfo4kR?qm|#C16kwWU$vA^EoB6NQd%bM%nHh`l&oU46V-
zHClA2e;$PpNH>BcwCIK7lE8cr+NK@KmP_V`P<A>Ln)Sf8Dbz3|Fu5lWrRhrFHeWUO
z$ci<L2uz<xpEKdNWYZ;o4Wk0X2Z=+mfY=cjdFuF1{7hh|xKr8|NEJ)l8Dwxh4Gq~0
z(ik7ZFmgQO2DZRVv3{Pn5vzUF6n9|_jgL`Go`xA_f`ol$x`-2)uUQ{6MbfKfa07E=
zn8mz6zK=jdK|t%Mfa_<li0L#IaEq5LPq!oR=;B&7+cIp>K|;QNMYU4B-{xxq=2gh0
zMJ_>CzIO%I2C`dQ0}U%zLwzhCD9eXj_~Pck%ya+e`Xnf;1j}62O+JMJ**YJ(mx<S;
z@U6m8;hJg?7~?mmip=+7nEx}F;NIZTEUs|_(&hI*F<JP5sjpB^4tY%XG=-ifTmFuz
zW2C>~=JE+{p9z;taHl6M^@O>uaJ(zL_pbbfg95AEkMI{PQrP_-wu~WeK)#DjC~RTz
z1jWl>>J%&u_A8uV<ub;XfKla}`Ug-;2MFv5`~^G$0015YlL18>lA$$!&q~8U5XNUs
z|HN8FpFr7DD@{WymQY0y!IPjU^uF0llWjMfu$$I{*az_~JP96r03S-6h#s7U`S^bO
z%`E%*_5J|>W7uQxvf126PdpZKi6-GwF6Vr}Ws#Rki%JzH$cqGtThu5V(q$%GATyLp
zx5^!#&V_b3;AI-*q6}1jy(6AXMsj>gSsVS$&sSO#aG3~3WYMI`AX;ToqHDB{-Xb0i
zPli#D;F>@Cz!-EMij|dktu!(?Dr_32RwNq3M=Qz_ZFncD?9w^RV~w^A4F>xQu@<2g
zCJk@n1<I-oEe5S~WmI*+;IMb|6HrB1Z$10(`ZESzuRrU851kGzv|)!q<BGljBWRMX
zi_!66oBA%f15%H)dHe?5*WW-5w!r%aP)i30>o8mVB$HpFWPeUcGjS4HN}-f0HVuj)
zBt)pi2yN9;D%b!Ou$X$mlgUXkFqs+8OrR{at9|fCv=92&*FJ@|tYsg3^WERje<AJ@
zE(rmbX06H0*_Ur$&bRlUf4}@4z$iS1Cl4MhWPXh0xv?hfLTo%{6l2Ml;Z$7H;=bwF
zsftq&B$vVx+<z0KEOReql!dY8RV!X>yvQw2Bx7zVRpD;RR2ccOu@PhR3faoczJIZ5
zStRhvJT*c`VV6u>2x;0SlCBHsQ7n>YhA$6iQU$Rd`#A*0pf5UAX^2~<B^ct4ETv15
z7c7z9klb~JOy7|Xy?j%6%4V9|q?8&03>~X{ou@5smw(dp`Bh=~8iEXGOTu5=^n6ii
zcrsj!XY1CclU6VjgS*G7Z(8YD?oKd7n)MoVhM?)~rqvc7yca<P?K;9Z#n9dGopdaV
zB2#Uih7N|1sJQ+nAu^naw+4xz6K8dtK^H?;L)FMr!#N6j)wE6jdOhsj2+pHdM-MJA
z^fYHUV}H9<f6<qMS2Vn(qO}xQcYRw&A1*QkEQc2u&Nqyj{Oh)t5L03L8BQ9O<B15~
zRe}33K-i63r@2?AQZ&SM463ApYhrUz_^suVh{_#8Qh}xz+7GETq^VV=FC_OJ$#CwF
z@64W@07ftx#{0O;(0Np^;R=IBY@HML{Rlopdw&>X$WXO538=;Us7(|h%yCR8yQ`Fe
z?@$Mbp{=&NQnI~{k9BDHgdyx5aB4V&8;97pYp&rY(b@C4^u1-%FB4DVM==$XZs9W>
zQ<!FW!>i`Ky%f6RGsoueIc_WKEcM!=sZzkijF|}LFs~GM=v-1aFc3dl?y((Mz@oaA
zC4X`x5-?<rar~c9cd@L9@D;=9s!f}~ESfxTiTVIU<1PF@IuG~owVH=-7%nux7pk^z
zR>ahOL%3?PG<>&D{-(~{sG3$mZG!I^`lqCHWOSn}?5JWosiW?}R7Hz45Z6M;|I3Zk
zC#9f+gJwObwvJ7+lKPKs9?F7BDWR+&On>!9d`TP=sY$X_md=Li)LwW?#|kR6y$<Gc
zzNvnPI6X;gmb#p!tvXk&<b_;P?tx1<Nd#3tViQ92F#JHL*9ejZ_$^Vx=_k;hqx;!5
zdUCn!7T(-OUv73NnM-UTTEjavytj?P-0dxp@$d_Lz%ZM9fsYs-W1K#&G34fI_<yu>
zvWA(*JFipp-4U)~Ha8xq;fr5){z~))hDiD)DQd_qKi&Bw@f_bi%RWUYN$9V(v69;c
z&m~qmjV%;wSgm1gXbbi$O0tW%_!C_8B3ge((T|6edOrs0=ZE;E{$`LQJ%u*f!o+r*
zz$5x55|i`<+WrAhO9u#DCi-vo0|Wp7_6Cyyi!+lhrzL-FPZL29$7i9?QjgLW5Tq({
zh<$)kTcB1zlqZ!0#k7KfkdSS=y&hcen!76`8u=i82484mW8w=xfFH^@+q=`!9=6HN
z?9Tr;yF0V{>-UeJ0FZ%A0-r7~^SKXVk(SPwS{9eZQbn8-OIociE7X)VHCfZj4Ci&G
zFlsOiR;hoHELB<Q%xKgMak)YjgUyL`DOscSq|9>^v)ObhvxHhb=kS$=qTqy4rO7l7
znJURDW4f$LID5`?1J}a&-2B3PE?H*h;zu740{(*5&`a#OtS|ymO_x%VPRj~QUFfu4
zXL{<LWj8goB1;XuwP!DQ2n0{*IZY{4l~Q}fQ&xX6z0glUD9eVa%f$xQ5eV$IR4Ox5
z`}v&}q}t;fcwhqI-G7-1Cf{+V?hQ4o1V-DZ3RRj}$`%?m0^av>-O9v0OB=uyFEst^
ztz2VT!z4g<2#lRmMJ`j5ZM7xZ*A<K&5$Io)RoPr4&>M>%2rvSpe(=Ig+{%mm`qu9D
z$$o!fJAd+W@71;s#s%=hjREL`2?B#osrdd3AKVr|u!4652w2`d0fsD36d(v8?%fw4
z48z=eKw!vV=GK+cg<@B0$2aAJ0j^IF7?!T;tpbe1;%>zpHr&Lcv2JbrpgXly(as#!
z?0ARvZ(9Tyw9dPLBI6nnUO(iIoc8&R_JMyDv6itT)*ytD*B$M}o?(MSMt8&$+u?_r
zK<MDQ_9KlKV8Zy1#1lK>X*`?w+8~YR^5P4}7sOkF9^v<)Wd+*~+BRU@A=_f}TNYc7
zHi#bHH2iMhXaTblw9&-j;qmcz7z^KOLL_{r36tEL;@)&98f?OhrwP%oz<(i#LEL{%
z5QZN71N0|mn=tFd=OAgvLumN|eTi=n`C^CXA?1cg9Q>gxKI!0TcYM;pGp_iegD<(`
ziw>T3#itznkvl%+;5k=(+QA>Y<I@hl3@a}9%x62i3QxN52zJN8*WjrO9(C|%u<nN2
zjm3M3-yZ1w15ir`2vW+pNbdpw08jx2lL18>lWM9rfBSb6MHK#qJ`zHBG%at?7=^ZJ
z((sU43aGSzR{EkTV2Xg-WRfo3?8e<qTR`xwp!j}*_(VYz6%@7=M1Jrbe(;a-cxN|h
zk~Z~lPEPL5%>C};yEAv@pMP)u1z-biGn_klvcL6sU`UFOa5WKV3&fLwP#~_QGqNI?
zvZjX9e_Ddmyv`La8Jre}B_kXk=J63Dn>GS%Nl7tyD3D2o(^4iZ3mZc%E$ibOHj%F0
zn#U)zib4~{uoPZTL$0P|m2+KIQ#3oub%T7-d~5T@=GJh6j|NV-!5BPIEvv`*E?MCW
z0ZmUuQo58-cw|hMG8wK%_B(RtIFDydO?RP^e__!PX;g|RlA4P24jtif(}ij>mC-fQ
zG-YluEa|d!vZky=`ljZ$Ff1r&IZhWinz9xVW74ROYid$XF*J6~9#4m@lhthw1!$|R
z%I2dC^$n%=%E!^TkD;QWai13pu*d@!Y6y9c-dw2lpbj-&crkx2s<6ZhH|C13WnOqN
ze@}d^VDJ{l;le5kl8?)VY1pm@y|@qed$1aQ;y}@)L?Jvc0$AuFD-SZv*SVC~K`>pN
zdpuNmAIDFVVv324v2-HW+`@x(&3G{;h8fnbVcZg8&1Ph@g<K}L$2JVhVJb<9WF-tm
zE@P2Q7m83G>dDkoo0zalR<}Kl9@BANuleUU@89SA&hNZl=kj}f&*u{~e#ubwupBpN
z!%}%=)hyoR!M@AD@YWqS`U&Jet0!mM^tRkIe@fCy>t<~w9`L$r>C*6XY*0~Q(u<~_
z67&qe+4<R7O04q(OM^nnwY$z{xXDi4#+O+?4Wt-YX(hh5)320ykT8(*R(7-8-q8HA
z$};bOVWyTEo;K=?)#Vh9Ps+B;$q<><!yNi-XyduxaZK5HDJt%n%kiv#pVGLi`iuU2
z0H12=8Bq7&<YYkzOJztiRmcy@xKG%XO1K3c2^027^`t4cl}MGIoa|@&&HPeBAf;qq
z-jj7f?zI2;|6JJ?BzvdwRH^^l^FscUJN18;>Zz1uLiTA;N^E%FtDifuhfU5DhQ;c-
z^=I0RjC%?)G{Hi1kHJt6O1cG8k?QblVhdih{V$xSXuF5Dw1Y)vT;*0=shc-(%>EHL
z^d^6uP5;#zhWem~$q(P+*|uiHaN@<2qa1~N74e*En69gy7lRgwDGH%G^4^g-CBIP!
z;==f{?D=46;>1Q0ag<YIN^r9d^C>B(?(JoHcjo0EDU<r>H&PLKBv+Ww%ka5po?&~X
zreO9`@uV`h_v}>kCnv)N_(ObgU2xd2RU50J;<_E_u!!_3m`r7Rx<~viV4XX#bou*F
z?d>_fyW_ESW>TNoS#q*dV<#<~#n&f?>Jnox2M2mhsuV9I6o)Wa_a?o~{h*v!eQ|d{
zrdq*4a&CXKy>)tA)g@k=PGEfAO?=KE!MHQqXxxX;nWfgAm-knGQT4T1ERhyC*u(os
z3A8->)abhwX9kV^c(Eje+2Z5%DJfYaFy&Ugz-2zq&5ie7xc|_oLwDX7?aek7wG)t;
z=VJKPD8cdcB*7neN|f?+io0(<T$J{BF}Eu`@g<cL@xagWT=q3>&eHn1K)SdBPL8hS
zsH;3uAzM}Hy)cr4SJ9L{Om}%MW^S_aPnl|C(K_$EE6HXrQZr@~$ui>NJ@*X8)U2x9
zM>YNz5rIv|iKKMx>u05lI?_vhysM3mlHcwhA_l6<k1I?~=Cr;{^-Wb}%?<f-uPrdi
zo|pn-`Fy(T=VstV_a^WA(@&^fmHYI*J$-Bj|0<MUiZ$v;y<k=UVWW?K{DhHlM!IOU
zPhI2$#ouH*5t}pRlcVbgo*uZ+#Ty9Ooags)R$MU%wG2iFTXC11vJ8!!cTLaRQ?IXY
zxk2psiJ^FpTY%4{y9UJHO=E=gb<ereN0K-13@vIFao&1ckdjR@cFy@nVlKW8EFZ>1
z3d7rv<KB!lY>{Rr$Y?cr$Mo@ptlPYclfka?v{d$PeHjHECG8WByHC;Me$=y0jU(a-
zO);-kZykzrJ*dWbh_U3q>Aa=!-ivFa9gy~r|0wRi-M(=mxuv^}Znqbze=WiLysrI5
zBy2TE`m?;Kt7_)7?(Gna@@x45k>}F8--=Y1_C~q4_8waJ*mCnxPb)KalNa^AzFp9I
z8*#*aJbQ34%`o}NOli;aiI8>0J$1fryZalPGoI-OY)s_VKb#*uJ;bMFTyEkg#*PXs
zYBgJ^^#jh@J!1wl=Z_{l9~lVp&aAB^WEohV;YL?iQujpKs%TyvQN%U=cs8B$8Oiej
zvb0{%;6&9Mvdh&3>oAIdBAls;)Dr;EKE4Z<$G}Y|!sP{pP(9xX#B@tN(S!>RV&LDu
z04&`8|7`&W)i;8WL4zq6wZE1c4d2QdVM9n=6m(1;fu`-0pounl@Ia09sQ?&kf*%0Q
zQK0))7}SCm8Vo^6>Nx=HMnUp;1lreV0e&3}Ymb8XDlkL`C4ru6Rn}=BDlS(nHXsp*
z(6K8@m@X}(aRQE5Umoac!X7+WYm~g)&M)9b$W%`ifhGBBYmZ7ze-$pjsspY@c)_Y>
zC{>;z0!lX-fJopH3<%*lazH^fyAUX*$qJO@nXH|0o+%7zLeHDjK}jaTTBzbXXh*Xn
zD6!H903+0{>}_E{6FS?h14`V)*B;%x9W>GG0j}Cv!-IB2sqA%tfo)LuHOK9%*2pkK
zKtVx{0JMXo0a044z*Uo8m@+|8g+wS-pak_&R?d&aest|Ve<dN{inFf?a(=${YP3M9
z8jx4v;#M<o#XxA;KM1a_L4k>sFQ77_D6yUafL$oi#s>jUglHk4<O>Q|6$KulBVbFL
z0z?Ymg1{cD)l~qXiGn{c5!gW>4XLFlEW;a+svxMYT?u1*boEcWY!FeBta}2$4wMo$
z=?kn2O4hLeKph47Wy6r|hLz=-PJt3;ii`A`78rpmFL2B6ZvbG7>J^oTK;#Y!spV%|
uD76ER5kg2?ZHGDd^@T?d)lu~X0vTVFhE)Dg$7#TGFE0lN-JMy!)cgY%mM|Cq

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index c61a118f7dd..1a704683a00 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/gradlew b/gradlew
index 23d15a93670..739907dfd15 100755
--- a/gradlew
+++ b/gradlew
@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -57,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/2d6327017519d23b96af35865dc997fcb544fb40/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -114,7 +114,6 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH="\\\"\\\""
 
 
 # Determine the Java command to use to start the JVM.
@@ -172,7 +171,6 @@ fi
 # For Cygwin or MSYS, switch paths to Windows format before running java
 if "$cygwin" || "$msys" ; then
     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
     JAVACMD=$( cygpath --unix "$JAVACMD" )
 
@@ -212,7 +210,6 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
         -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 
diff --git a/gradlew.bat b/gradlew.bat
index db3a6ac207e..c4bdd3ab8e3 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -70,11 +70,10 @@ goto fail
 :execute
 @rem Setup the command line
 
-set CLASSPATH=
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
 
 :end
 @rem End local scope for the variables with windows NT shell

From c7ed38cb3bf1241be0ebf27a7df97a2b13b118e8 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Tue, 5 May 2026 13:49:10 +0200
Subject: [PATCH 130/391] feat(ci): Notify linked issues on release (#5367)

Add a release workflow that comments on GitHub issues closed by PRs
included in a published stable release.

Also document that PR authors need to use GitHub closing keywords for
linked issues to receive the release notification.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/workflows/release-comment-issues.yml | 39 ++++++++++++++++++++
 CONTRIBUTING.md                              |  7 ++++
 2 files changed, 46 insertions(+)
 create mode 100644 .github/workflows/release-comment-issues.yml

diff --git a/.github/workflows/release-comment-issues.yml b/.github/workflows/release-comment-issues.yml
new file mode 100644
index 00000000000..0eeff26b9d8
--- /dev/null
+++ b/.github/workflows/release-comment-issues.yml
@@ -0,0 +1,39 @@
+name: 'Automation: Notify issues for release'
+on:
+  release:
+    types:
+      - published
+  workflow_dispatch:
+    inputs:
+      version:
+        description: Which version to notify issues for
+        required: true
+
+permissions:
+  contents: read
+  issues: write
+  pull-requests: read
+
+jobs:
+  release-comment-issues:
+    runs-on: ubuntu-24.04
+    name: 'Notify issues'
+    steps:
+      - name: Get version
+        id: get_version
+        env:
+          INPUTS_VERSION: ${{ github.event.inputs.version }}
+          RELEASE_TAG_NAME: ${{ github.event.release.tag_name }}
+        run: echo "version=${INPUTS_VERSION:-$RELEASE_TAG_NAME}" >> "$GITHUB_OUTPUT"
+
+      - name: Comment on linked issues that are mentioned in release
+        if: |
+          steps.get_version.outputs.version != ''
+          && !contains(steps.get_version.outputs.version, '-beta.')
+          && !contains(steps.get_version.outputs.version, '-alpha.')
+          && !contains(steps.get_version.outputs.version, '-rc.')
+
+        uses: getsentry/release-comment-issues-gh-action@v1
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          version: ${{ steps.get_version.outputs.version }}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8e2c8b78bf1..7eb38413d64 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -57,6 +57,13 @@ or
 
 However, if your change did not intend to modify the public API, consider changing the method/property visibility or removing the change altogether.
 
+# Linking issues
+
+If a PR should notify a linked issue after release, use a GitHub closing keyword in the PR
+description, such as `Fixes #123`, `Closes #123`, or `Resolves #123`. Release notification
+automation only comments on issues GitHub recognizes as closed by the released PR; mentioning an
+issue without a closing keyword is not enough.
+
 # CI
 
 Build and tests are automatically run against branches and pull requests

From d25ef951db8d52542757932b3dbe4497e60f8465 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 5 May 2026 14:32:55 +0200
Subject: [PATCH 131/391] chore(deps): update Native SDK to v0.14.0 (#5365)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 +++---
 gradle/libs.versions.toml | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2aee24e7775..213fe354ffe 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -26,9 +26,9 @@
 
 ### Dependencies
 
-- Bump Native SDK from v0.13.7 to v0.13.8 ([#5334](https://github.com/getsentry/sentry-java/pull/5334))
-  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0138)
-  - [diff](https://github.com/getsentry/sentry-native/compare/0.13.7...0.13.8)
+- Bump Native SDK from v0.13.7 to v0.14.0 ([#5334](https://github.com/getsentry/sentry-java/pull/5334), [#5365](https://github.com/getsentry/sentry-java/pull/5365))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0140)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.13.7...0.14.0)
 - Bump Gradle from v9.4.1 to v9.5.0 ([#5344](https://github.com/getsentry/sentry-java/pull/5344))
   - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v950)
   - [diff](https://github.com/gradle/gradle/compare/v9.4.1...v9.5.0)
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c04ab824c86..cf7bc7b4f32 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -151,7 +151,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.13.8" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.14.0" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From e3e78e1c6cc641228dd910ee39c28ed6cf1ee710 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Tue, 5 May 2026 14:37:35 +0200
Subject: [PATCH 132/391] fix(feedback): Improve shake detection sensitivity
 (#5366)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(feedback): Improve shake detection sensitivity

Replace the threshold-counting approach (2.7g, 2 spikes in 1.5s) with
a rolling sample window based on Square's Seismic library. A shake is
now detected when >75% of accelerometer readings in a 0.5s window
exceed 13 m/s² (~1.33g), which works reliably on budget devices with
less sensitive accelerometers.

Fixes GH-5331

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs: Add license attribution for Square's Seismic library

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* docs: Add third-party code attribution guidelines to AGENTS.md

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Format code

* docs(changelog): Add shake detection fix entry

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): Clear message field when form is re-shown via shake

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): Synchronize SampleQueue access across threads

stop() runs on the main thread while onSensorChanged() runs on the
background HandlerThread. Without synchronization, concurrent access
to the linked list and object pool can corrupt next-pointers and
cause clear() to loop forever.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref(feedback): Replace synchronized block with handler.post for queue clear

Post queue.clear() to the HandlerThread instead of synchronizing every
sensor event. All queue access now stays single-threaded with zero
lock contention. quitSafely() drains pending messages before exiting.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* dont use method ref

* ref(feedback): Remove queue.clear() from stop(), rely on timestamp purge

Sensor events are delivered via fd callbacks, not Handler messages, so
posting clear() to the HandlerThread doesn't guarantee ordering with
new events after re-registration. The SampleQueue already purges stale
samples by timestamp in add(), so explicit clearing on stop is
unnecessary.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref(feedback): Restore handler.post(clear) in stop()

Both fd callbacks and posted Messages are serialized by the Looper,
so there is no concurrent access risk. Explicit clear is cleaner than
relying on timestamp purge alone.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(feedback): Require minimum sample count before triggering shake

The 75% bit-shift formula degrades at low sample counts (e.g. 33% at
3 samples). With SENSOR_DELAY_NORMAL (~5Hz) the queue may hold only
3 samples in 0.5s. Adding a MIN_QUEUE_SIZE guard ensures the threshold
stays accurate and prevents false triggers from walking.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 AGENTS.md                                     |  11 ++
 CHANGELOG.md                                  |   2 +
 THIRD_PARTY_NOTICES.md                        |  28 +++
 .../android/core/SentryShakeDetector.java     | 160 +++++++++++++-----
 .../android/core/SentryUserFeedbackForm.java  |   6 +
 .../android/core/SentryShakeDetectorTest.kt   |  88 ++++++++--
 6 files changed, 239 insertions(+), 56 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index fad3dc5a54e..42a8e651004 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -144,6 +144,17 @@ The repository is organized into multiple modules:
 4. New features must be **opt-in by default** - extend `SentryOptions` or similar Option classes with getters/setters
 5. Consider backwards compatibility
 
+### Third-Party Code Attribution
+When adapting code from third-party libraries:
+1. Add a license header at the top of the adapted file (before the `package` statement):
+   ```java
+   // Adapted from <Library Name>.
+   // Copyright <year> <copyright holder>.
+   // Licensed under the <License Name>.
+   // <source URL>
+   ```
+2. Add a full attribution entry to `THIRD_PARTY_NOTICES.md` following the existing format (Source, License, Copyright, Scope, full license text)
+
 ### Getting PR Information
 
 Use `gh pr view` to get PR details from the current branch. This is needed when adding changelog entries, which require the PR number.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 213fe354ffe..ea6befb4b35 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,8 @@
 ### Fixes
 
 - Fix soft input keyboard not being shown on the Feedback form ([#5359](https://github.com/getsentry/sentry-java/pull/5359))
+- Fix shake-to-report not triggering on some devices due to high acceleration threshold ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
+- Fix feedback form retaining previous message when shown again via shake ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
 
 ### Dependencies
 
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index 8b2141cc59e..5a48d567fac 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -118,6 +118,34 @@ limitations under the License.
 
 ---
 
+## Square — Seismic (Apache 2.0)
+
+**Source:** https://github.com/square/seismic<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright 2010 Square, Inc.
+
+### Scope
+
+The Sentry Java SDK includes an adapted version of Square's Seismic shake detection algorithm. The rolling sample window approach and `SampleQueue`/`SamplePool` data structures in `io.sentry.android.core.SentryShakeDetector` are based on Seismic's `ShakeDetector`.
+
+```
+Copyright 2010 Square, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
 ## Square — Curtains (Apache 2.0)
 
 **Source:** https://github.com/square/curtains (v1.2.5)<br>
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java
index 5b6f63309ff..a4c4ae0c4f5 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java
@@ -1,3 +1,7 @@
+// Adapted from Square's Seismic library.
+// Copyright 2010 Square, Inc.
+// Licensed under the Apache License, Version 2.0.
+// https://github.com/square/seismic
 package io.sentry.android.core;
 
 import android.content.Context;
@@ -7,10 +11,8 @@
 import android.hardware.SensorManager;
 import android.os.Handler;
 import android.os.HandlerThread;
-import android.os.SystemClock;
 import io.sentry.ILogger;
 import io.sentry.SentryLevel;
-import java.util.concurrent.atomic.AtomicLong;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -21,8 +23,8 @@
  * <p>The accelerometer sensor (TYPE_ACCELEROMETER) does NOT require any special permissions on
  * Android. The BODY_SENSORS permission is only needed for heart rate and similar body sensors.
  *
- * <p>Requires at least {@link #SHAKE_COUNT_THRESHOLD} accelerometer readings above {@link
- * #SHAKE_THRESHOLD_GRAVITY} within {@link #SHAKE_WINDOW_MS} to trigger a shake event.
+ * <p>Uses a rolling sample window: if more than 75% of accelerometer readings in the past 0.5s
+ * exceed {@link #ACCELERATION_THRESHOLD}, a shake is detected. Based on Square's Seismic library.
  *
  * <p>Sensor events are delivered on a background {@link HandlerThread} to avoid polluting the main
  * thread.
@@ -30,21 +32,16 @@
 @ApiStatus.Internal
 public final class SentryShakeDetector implements SensorEventListener {
 
-  private static final float SHAKE_THRESHOLD_GRAVITY = 2.7f;
-  private static final int SHAKE_WINDOW_MS = 1500;
-  private static final int SHAKE_COUNT_THRESHOLD = 2;
-  private static final int SHAKE_COOLDOWN_MS = 1000;
+  static final int ACCELERATION_THRESHOLD = 13;
 
   private @Nullable SensorManager sensorManager;
   private @Nullable Sensor accelerometer;
   private @Nullable HandlerThread handlerThread;
   private @Nullable Handler handler;
-  private final @NotNull AtomicLong lastShakeTimestamp = new AtomicLong(0);
   private volatile @Nullable Listener listener;
   private @NotNull ILogger logger;
 
-  private int shakeCount = 0;
-  private long firstShakeTimestamp = 0;
+  private final @NotNull SampleQueue queue = new SampleQueue();
 
   public interface Listener {
     void onShake();
@@ -94,17 +91,24 @@ public void start(final @NotNull Context context, final @NotNull Listener shakeL
 
   public void stop() {
     listener = null;
-    shakeCount = 0;
-    firstShakeTimestamp = 0;
     if (sensorManager != null) {
       sensorManager.unregisterListener(this);
     }
+    final @Nullable Handler h = handler;
+    if (h != null) {
+      h.post(
+          () -> {
+            //noinspection Convert2MethodRef
+            queue.clear();
+          });
+    }
   }
 
   /** Stops detection and releases the background thread. */
   public void close() {
     stop();
     if (handlerThread != null) {
+      // quitSafely drains pending messages (including the clear posted by stop) before exiting
       handlerThread.quitSafely();
       handlerThread = null;
       handler = null;
@@ -116,32 +120,17 @@ public void onSensorChanged(final @NotNull SensorEvent event) {
     if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) {
       return;
     }
-    float gX = event.values[0] / SensorManager.GRAVITY_EARTH;
-    float gY = event.values[1] / SensorManager.GRAVITY_EARTH;
-    float gZ = event.values[2] / SensorManager.GRAVITY_EARTH;
-    double gForceSquared = gX * gX + gY * gY + gZ * gZ;
-    if (gForceSquared > SHAKE_THRESHOLD_GRAVITY * SHAKE_THRESHOLD_GRAVITY) {
-      long now = SystemClock.elapsedRealtime();
-
-      // Reset counter if outside the detection window
-      if (now - firstShakeTimestamp > SHAKE_WINDOW_MS) {
-        shakeCount = 0;
-        firstShakeTimestamp = now;
-      }
-
-      shakeCount++;
-
-      if (shakeCount >= SHAKE_COUNT_THRESHOLD) {
-        // Enforce cooldown so we don't fire repeatedly
-        long lastShake = lastShakeTimestamp.get();
-        if (now - lastShake > SHAKE_COOLDOWN_MS) {
-          lastShakeTimestamp.set(now);
-          shakeCount = 0;
-          final @Nullable Listener currentListener = listener;
-          if (currentListener != null) {
-            currentListener.onShake();
-          }
-        }
+    final float ax = event.values[0];
+    final float ay = event.values[1];
+    final float az = event.values[2];
+    final boolean accelerating = Math.sqrt(ax * ax + ay * ay + az * az) > ACCELERATION_THRESHOLD;
+
+    queue.add(event.timestamp, accelerating);
+    if (queue.isShaking()) {
+      queue.clear();
+      final @Nullable Listener currentListener = listener;
+      if (currentListener != null) {
+        currentListener.onShake();
       }
     }
   }
@@ -150,4 +139,97 @@ public void onSensorChanged(final @NotNull SensorEvent event) {
   public void onAccuracyChanged(final @NotNull Sensor sensor, final int accuracy) {
     // Not needed for shake detection.
   }
+
+  static class SampleQueue {
+    private static final long MAX_WINDOW_SIZE_NS = 500_000_000L; // 0.5s
+    private static final long MIN_WINDOW_SIZE_NS = MAX_WINDOW_SIZE_NS >> 1; // 0.25s
+    private static final int MIN_QUEUE_SIZE = 4;
+
+    private final @NotNull SamplePool pool = new SamplePool();
+    private @Nullable Sample oldest;
+    private @Nullable Sample newest;
+    private int sampleCount;
+    private int acceleratingCount;
+
+    void add(final long timestamp, final boolean accelerating) {
+      purge(timestamp - MAX_WINDOW_SIZE_NS);
+
+      final @NotNull Sample added = pool.acquire();
+      added.timestamp = timestamp;
+      added.accelerating = accelerating;
+      added.next = null;
+      if (newest != null) {
+        newest.next = added;
+      }
+      newest = added;
+      if (oldest == null) {
+        oldest = added;
+      }
+
+      sampleCount++;
+      if (accelerating) {
+        acceleratingCount++;
+      }
+    }
+
+    void clear() {
+      while (oldest != null) {
+        final @NotNull Sample removed = oldest;
+        oldest = removed.next;
+        pool.release(removed);
+      }
+      newest = null;
+      sampleCount = 0;
+      acceleratingCount = 0;
+    }
+
+    private void purge(final long cutoff) {
+      while (sampleCount >= MIN_QUEUE_SIZE && oldest != null && cutoff - oldest.timestamp > 0) {
+        final @NotNull Sample removed = oldest;
+        if (removed.accelerating) {
+          acceleratingCount--;
+        }
+        sampleCount--;
+        oldest = removed.next;
+        if (oldest == null) {
+          newest = null;
+        }
+        pool.release(removed);
+      }
+    }
+
+    boolean isShaking() {
+      return newest != null
+          && oldest != null
+          && sampleCount >= MIN_QUEUE_SIZE
+          && newest.timestamp - oldest.timestamp >= MIN_WINDOW_SIZE_NS
+          && acceleratingCount >= (sampleCount >> 1) + (sampleCount >> 2);
+    }
+  }
+
+  static class Sample {
+    long timestamp;
+    boolean accelerating;
+    @Nullable Sample next;
+  }
+
+  static class SamplePool {
+    private @Nullable Sample head;
+
+    @NotNull
+    Sample acquire() {
+      Sample acquired = head;
+      if (acquired == null) {
+        acquired = new Sample();
+      } else {
+        head = acquired.next;
+      }
+      return acquired;
+    }
+
+    void release(final @NotNull Sample sample) {
+      sample.next = head;
+      head = sample;
+    }
+  }
 }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
index 2800d5670a8..43500d50ebc 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
@@ -324,6 +324,12 @@ public void setOnDismissListener(final @Nullable OnDismissListener listener) {
   @Override
   protected void onStart() {
     super.onStart();
+    // Clear the message field so subsequent show() calls start with a fresh form
+    final @NotNull EditText edtMessage =
+        findViewById(R.id.sentry_dialog_user_feedback_edt_description);
+    edtMessage.getText().clear();
+    edtMessage.setError(null);
+
     final @NotNull SentryOptions options = Sentry.getCurrentScopes().getOptions();
     final @NotNull SentryFeedbackOptions feedbackOptions = options.getFeedbackOptions();
     final @Nullable Runnable onFormOpen = feedbackOptions.getOnFormOpen();
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt
index 98441e48a8d..24ccfceaa86 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShakeDetectorTest.kt
@@ -5,10 +5,11 @@ import android.hardware.Sensor
 import android.hardware.SensorEvent
 import android.hardware.SensorManager
 import android.os.Handler
-import android.os.SystemClock
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.ILogger
 import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
 import org.mockito.kotlin.eq
@@ -88,29 +89,27 @@ class SentryShakeDetectorTest {
   }
 
   @Test
-  fun `triggers listener when shake is detected`() {
-    // Advance clock so cooldown check (now - 0 > 1000) passes
-    SystemClock.setCurrentTimeMillis(2000)
-
+  fun `triggers listener when sustained shake is detected`() {
     val sut = fixture.getSut()
     sut.start(fixture.context, fixture.listener)
 
-    // Needs at least SHAKE_COUNT_THRESHOLD (2) readings above threshold
-    val event1 = createSensorEvent(floatArrayOf(30f, 0f, 0f))
-    sut.onSensorChanged(event1)
-    val event2 = createSensorEvent(floatArrayOf(30f, 0f, 0f))
-    sut.onSensorChanged(event2)
+    // Send enough accelerating samples over 0.25s+ to trigger (>75% accelerating)
+    val baseTimestamp = 1_000_000_000L // 1s in nanos
+    val intervalNs = 20_000_000L // 20ms between samples (~50Hz)
+    for (i in 0 until 20) {
+      val event = createSensorEvent(floatArrayOf(20f, 0f, 0f), baseTimestamp + i * intervalNs)
+      sut.onSensorChanged(event)
+    }
 
     verify(fixture.listener).onShake()
   }
 
   @Test
-  fun `does not trigger listener on single shake`() {
+  fun `does not trigger listener on single spike`() {
     val sut = fixture.getSut()
     sut.start(fixture.context, fixture.listener)
 
-    // A single threshold crossing should not trigger
-    val event = createSensorEvent(floatArrayOf(30f, 0f, 0f))
+    val event = createSensorEvent(floatArrayOf(30f, 0f, 0f), 1_000_000_000L)
     sut.onSensorChanged(event)
 
     verify(fixture.listener, never()).onShake()
@@ -121,9 +120,16 @@ class SentryShakeDetectorTest {
     val sut = fixture.getSut()
     sut.start(fixture.context, fixture.listener)
 
-    // Gravity only (1G) - no shake
-    val event = createSensorEvent(floatArrayOf(0f, 0f, SensorManager.GRAVITY_EARTH))
-    sut.onSensorChanged(event)
+    val baseTimestamp = 1_000_000_000L
+    val intervalNs = 20_000_000L
+    for (i in 0 until 20) {
+      val event =
+        createSensorEvent(
+          floatArrayOf(0f, 0f, SensorManager.GRAVITY_EARTH),
+          baseTimestamp + i * intervalNs,
+        )
+      sut.onSensorChanged(event)
+    }
 
     verify(fixture.listener, never()).onShake()
   }
@@ -133,7 +139,7 @@ class SentryShakeDetectorTest {
     val sut = fixture.getSut()
     sut.start(fixture.context, fixture.listener)
 
-    val event = createSensorEvent(floatArrayOf(30f, 0f, 0f), sensorType = Sensor.TYPE_GYROSCOPE)
+    val event = createSensorEvent(floatArrayOf(30f, 0f, 0f), 1_000_000_000L, Sensor.TYPE_GYROSCOPE)
     sut.onSensorChanged(event)
 
     verify(fixture.listener, never()).onShake()
@@ -145,8 +151,53 @@ class SentryShakeDetectorTest {
     sut.stop()
   }
 
+  @Test
+  fun `sample queue triggers when 75 percent of samples are accelerating`() {
+    val queue = SentryShakeDetector.SampleQueue()
+    val intervalNs = 20_000_000L
+
+    // 15 accelerating + 5 not = 75% in a 0.4s window (> 0.25s minimum)
+    for (i in 0 until 15) {
+      queue.add(i * intervalNs, true)
+    }
+    for (i in 15 until 20) {
+      queue.add(i * intervalNs, false)
+    }
+
+    assertTrue(queue.isShaking())
+  }
+
+  @Test
+  fun `sample queue does not trigger below 75 percent`() {
+    val queue = SentryShakeDetector.SampleQueue()
+    val intervalNs = 20_000_000L
+
+    // 10 accelerating + 10 not = 50%
+    for (i in 0 until 10) {
+      queue.add(i * intervalNs, true)
+    }
+    for (i in 10 until 20) {
+      queue.add(i * intervalNs, false)
+    }
+
+    assertFalse(queue.isShaking())
+  }
+
+  @Test
+  fun `sample queue does not trigger below minimum window`() {
+    val queue = SentryShakeDetector.SampleQueue()
+
+    // All accelerating but only 0.06s apart (below 0.25s minimum)
+    for (i in 0 until 4) {
+      queue.add(i * 20_000_000L, true)
+    }
+
+    assertFalse(queue.isShaking())
+  }
+
   private fun createSensorEvent(
     values: FloatArray,
+    timestamp: Long = 0L,
     sensorType: Int = Sensor.TYPE_ACCELEROMETER,
   ): SensorEvent {
     val sensor = mock<Sensor>()
@@ -160,6 +211,9 @@ class SentryShakeDetectorTest {
     val sensorField = SensorEvent::class.java.getField("sensor")
     sensorField.set(event, sensor)
 
+    val timestampField = SensorEvent::class.java.getField("timestamp")
+    timestampField.set(event, timestamp)
+
     return event
   }
 }

From 83a416d1cfa89e79f71fd8eb9fe05d8e5058f665 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Denis=20Andra=C5=A1ec?= <denrase@gmail.com>
Date: Wed, 6 May 2026 10:50:23 +0200
Subject: [PATCH 133/391] fix: Avoid stack overflow when deserializing large
 flat JSON objects (#5361)

* fix: Avoid stack overflow when deserializing large flat JSON objects

Replace JsonObjectDeserializer's recursive token parsing with an iterative loop. The parser already tracks state explicitly, so recursion was only used to advance to the next JSON token and could overflow on large flat maps.

Relates to https://github.com/getsentry/sentry-dart/issues/3668

* use larger module count

vm might not respect stack size, so increase the frame count (with smaller payload) to make test more robust

* add cl entries

* fix cl entry

* Update CHANGELOG.md

---------

Co-authored-by: Giancarlo Buenaflor <giancarlo_buenaflor@yahoo.com>
---
 CHANGELOG.md                                  |  4 +
 .../io/sentry/JsonObjectDeserializer.java     | 85 +++++++++----------
 .../test/java/io/sentry/SentryEventTest.kt    | 44 ++++++++++
 3 files changed, 90 insertions(+), 43 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ea6befb4b35..a5c606a2bce 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -35,6 +35,10 @@
   - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v950)
   - [diff](https://github.com/gradle/gradle/compare/v9.4.1...v9.5.0)
 
+### Fixes
+
+- Avoid stack overflow when deserializing large flat JSON objects ([#5361](https://github.com/getsentry/sentry-java/pull/5361))
+
 ## 8.40.0
 
 ### Fixes
diff --git a/sentry/src/main/java/io/sentry/JsonObjectDeserializer.java b/sentry/src/main/java/io/sentry/JsonObjectDeserializer.java
index e7753d44ea7..0916f6e82d5 100644
--- a/sentry/src/main/java/io/sentry/JsonObjectDeserializer.java
+++ b/sentry/src/main/java/io/sentry/JsonObjectDeserializer.java
@@ -82,49 +82,48 @@ private static final class TokenMap implements Token {
 
   private void parse(@NotNull JsonObjectReader reader) throws IOException {
     boolean done = false;
-    switch (reader.peek()) {
-      case BEGIN_ARRAY:
-        reader.beginArray();
-        pushCurrentToken(new TokenArray());
-        break;
-      case END_ARRAY:
-        reader.endArray();
-        done = handleArrayOrMapEnd();
-        break;
-      case BEGIN_OBJECT:
-        reader.beginObject();
-        pushCurrentToken(new TokenMap());
-        break;
-      case END_OBJECT:
-        reader.endObject();
-        done = handleArrayOrMapEnd();
-        break;
-      case NAME:
-        pushCurrentToken(new TokenName(reader.nextName()));
-        break;
-      case STRING:
-        // avoid method refs on Android due to some issues with older AGP setups
-        // noinspection Convert2MethodRef
-        done = handlePrimitive(() -> reader.nextString());
-        break;
-      case NUMBER:
-        done = handlePrimitive(() -> nextNumber(reader));
-        break;
-      case BOOLEAN:
-        // avoid method refs on Android due to some issues with older AGP setups
-        // noinspection Convert2MethodRef
-        done = handlePrimitive(() -> reader.nextBoolean());
-        break;
-      case NULL:
-        reader.nextNull();
-        done = handlePrimitive(() -> null);
-        break;
-      case END_DOCUMENT:
-        done = true;
-        break;
-    }
-    if (!done) {
-      parse(reader);
+    while (!done) {
+      switch (reader.peek()) {
+        case BEGIN_ARRAY:
+          reader.beginArray();
+          pushCurrentToken(new TokenArray());
+          break;
+        case END_ARRAY:
+          reader.endArray();
+          done = handleArrayOrMapEnd();
+          break;
+        case BEGIN_OBJECT:
+          reader.beginObject();
+          pushCurrentToken(new TokenMap());
+          break;
+        case END_OBJECT:
+          reader.endObject();
+          done = handleArrayOrMapEnd();
+          break;
+        case NAME:
+          pushCurrentToken(new TokenName(reader.nextName()));
+          break;
+        case STRING:
+          // avoid method refs on Android due to some issues with older AGP setups
+          // noinspection Convert2MethodRef
+          done = handlePrimitive(() -> reader.nextString());
+          break;
+        case NUMBER:
+          done = handlePrimitive(() -> nextNumber(reader));
+          break;
+        case BOOLEAN:
+          // avoid method refs on Android due to some issues with older AGP setups
+          // noinspection Convert2MethodRef
+          done = handlePrimitive(() -> reader.nextBoolean());
+          break;
+        case NULL:
+          reader.nextNull();
+          done = handlePrimitive(() -> null);
+          break;
+        case END_DOCUMENT:
+          done = true;
+          break;
+      }
     }
   }
 
diff --git a/sentry/src/test/java/io/sentry/SentryEventTest.kt b/sentry/src/test/java/io/sentry/SentryEventTest.kt
index 36782c153e1..70514a6b72d 100644
--- a/sentry/src/test/java/io/sentry/SentryEventTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryEventTest.kt
@@ -3,9 +3,11 @@ package io.sentry
 import io.sentry.exception.ExceptionMechanismException
 import io.sentry.protocol.Mechanism
 import io.sentry.protocol.SentryId
+import java.io.StringReader
 import java.time.Instant
 import java.time.temporal.ChronoUnit
 import java.util.Collections
+import java.util.concurrent.atomic.AtomicReference
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -174,6 +176,48 @@ class SentryEventTest {
     }
   }
 
+  @Test
+  fun `deserializes event with large flat modules map on a small stack`() {
+    val moduleCount = 50000
+    val json = buildString {
+      append("{\"event_id\":\"00000000000000000000000000000000\",\"modules\":{")
+      repeat(moduleCount) {
+        if (it > 0) {
+          append(',')
+        }
+        append("\"m")
+        append(it)
+        append("\":\"v\"")
+      }
+      append("}}")
+    }
+
+    val error = AtomicReference<Throwable?>()
+    val event = AtomicReference<SentryEvent?>()
+    val thread =
+      Thread(
+        null,
+        Runnable {
+          try {
+            event.set(
+              JsonSerializer(SentryOptions())
+                .deserialize(StringReader(json), SentryEvent::class.java)
+            )
+          } catch (throwable: Throwable) {
+            error.set(throwable)
+          }
+        },
+        "large-flat-modules-repro",
+        1024L * 1024L,
+      )
+
+    thread.start()
+    thread.join()
+
+    assertNull(error.get())
+    assertEquals(moduleCount, event.get()?.modules?.size)
+  }
+
   @Test
   fun `null tag does not cause NPE`() {
     val event = SentryEvent()

From 0188f486bee02039e435beaa70a120f93bcf390c Mon Sep 17 00:00:00 2001
From: Giancarlo Buenaflor <giancarlo_buenaflor@yahoo.com>
Date: Wed, 6 May 2026 13:18:01 +0200
Subject: [PATCH 134/391] chore: Fix entry in `CHANGELOG`

Refactored duplicate `Fixes` entry
---
 CHANGELOG.md | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a5c606a2bce..9b945938d2b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,6 +25,7 @@
 - Fix soft input keyboard not being shown on the Feedback form ([#5359](https://github.com/getsentry/sentry-java/pull/5359))
 - Fix shake-to-report not triggering on some devices due to high acceleration threshold ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
 - Fix feedback form retaining previous message when shown again via shake ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
+- Avoid stack overflow when deserializing large flat JSON objects ([#5361](https://github.com/getsentry/sentry-java/pull/5361))
 
 ### Dependencies
 
@@ -35,10 +36,6 @@
   - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v950)
   - [diff](https://github.com/gradle/gradle/compare/v9.4.1...v9.5.0)
 
-### Fixes
-
-- Avoid stack overflow when deserializing large flat JSON objects ([#5361](https://github.com/getsentry/sentry-java/pull/5361))
-
 ## 8.40.0
 
 ### Fixes

From 11ad3372fed13e4508810060fd3997fb786ac176 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 6 May 2026 15:39:45 +0200
Subject: [PATCH 135/391] feat(core): Queue Instrumentation for Kafka (#5249)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* collection: Queue Instrumentation

* feat(core): Add enableQueueTracing option and messaging span data conventions

Add enableQueueTracing boolean to SentryOptions (default false) and
ExternalOptions (nullable Boolean) with merge support. Add messaging.*
keys to SpanDataConvention for queue instrumentation span data.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* feat(samples): Add Kafka producer and consumer to Spring Boot 3 sample app

Add spring-kafka dependency and a simple Kafka producer/consumer setup
behind a 'kafka' Spring profile. Includes a REST endpoint to produce
messages and a KafkaListener that consumes them.

Kafka auto-configuration is excluded by default and only activated
when the 'kafka' profile is enabled.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(spring-jakarta): Add Kafka producer instrumentation

Add SentryKafkaProducerWrapper that overrides doSend to create
queue.publish spans for all KafkaTemplate send operations. Injects
sentry-trace, baggage, and sentry-task-enqueued-time headers for
distributed tracing and receive latency calculation.

Add SentryKafkaProducerBeanPostProcessor to automatically wrap
KafkaTemplate beans.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* feat(spring-jakarta): Add Kafka consumer instrumentation

Add SentryKafkaRecordInterceptor that creates queue.process transactions
for incoming Kafka records. Forks scopes per record, extracts sentry-trace
and baggage headers for distributed tracing via continueTrace, and
calculates messaging.message.receive.latency from the enqueued-time header.

Composes with existing RecordInterceptor via delegation. Span lifecycle
is managed through success/failure callbacks.

Add SentryKafkaConsumerBeanPostProcessor to register the interceptor on
ConcurrentKafkaListenerContainerFactory beans.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* feat(spring-boot-jakarta): Add Kafka queue auto-configuration

Register SentryKafkaProducerBeanPostProcessor and
SentryKafkaConsumerBeanPostProcessor when spring-kafka is on the
classpath and sentry.enable-queue-tracing=true. Follows the same
pattern as SentryCacheConfiguration.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* test(samples): Add Kafka queue system tests for Spring Boot 3

Add KafkaQueueSystemTest with e2e tests for:
- Producer endpoint creates queue.publish span
- Consumer creates queue.process transaction
- Distributed tracing (producer and consumer share same trace)
- Messaging attributes on publish span and process transaction

Also add produceKafkaMessage to RestTestClient and enable
sentry.enable-queue-tracing in the kafka profile properties.

Requires a running Kafka broker at localhost:9092 and the sample app
started with --spring.profiles.active=kafka.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs: Add rule against force-pushing stack branches

Force-pushing a stack branch can cause GitHub to auto-merge or
auto-close other PRs in the stack. Add explicit guidance to never
use --force, --force-with-lease, or amend+push on stack branches.

* docs: Also prohibit --amend on stack branches

* feat(samples): Add Kafka producer and consumer to Spring Boot 3 OTel sample apps

Add Kafka queue tracing support to both the OTel agent and agentless
Spring Boot 3 sample applications. Each sample gets a KafkaController
for producing messages and a KafkaConsumer listener, activated via the
'kafka' Spring profile. Kafka auto-configuration is excluded by default
and only enabled when the kafka profile is active.

* fix(spring-boot-jakarta): Disable Sentry Kafka instrumentation when OTel is active

Skip registration of SentryKafkaProducerBeanPostProcessor and
SentryKafkaConsumerBeanPostProcessor when a Sentry OpenTelemetry
integration (agent or agentless) is on the classpath. OpenTelemetry
provides its own Kafka instrumentation, so Sentry's would create
duplicate spans.

* fix(core): Add Kafka span origins to ignored list for OpenTelemetry

Add auto.queue.spring_jakarta.kafka.producer and
auto.queue.spring_jakarta.kafka.consumer to the ignored span origins
when running with OTel agent or agentless-spring. Prevents duplicate
spans when both Sentry and OTel Kafka instrumentation are active.

* ref(spring-jakarta): Replace SentryKafkaProducerWrapper with SentryProducerInterceptor

Replace the KafkaTemplate subclass approach with a Kafka-native
ProducerInterceptor. The BeanPostProcessor now sets the interceptor
on the existing KafkaTemplate instead of replacing the bean, which
preserves any custom configuration on the template.

Existing customer interceptors are composed using Spring's
CompositeProducerInterceptor. If reflection fails to read the
existing interceptor, a warning is logged.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): Update consumer references and add reflection warning log

Update SentryKafkaRecordInterceptor and its test to reference
SentryProducerInterceptor instead of the removed
SentryKafkaProducerWrapper.

Add a warning log in SentryKafkaConsumerBeanPostProcessor when
reflection fails to read the existing RecordInterceptor, so users
know their custom interceptor may not be chained.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): Initialize Sentry in SentryProducerInterceptorTest

TransactionContext constructor requires ScopesAdapter.getOptions() to
be non-null for thread checker access. Add initForTest/close to
ensure Sentry is properly initialized during tests.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): Initialize Sentry in consumer test, fix API file ordering

Add initForTest/close to SentryKafkaRecordInterceptorTest to fix NPE
from TransactionContext constructor requiring initialized Sentry.

Regenerate API file to fix alphabetical ordering of
SentryProducerInterceptor entry.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): Clean up stale ThreadLocal context in Kafka consumer interceptor

Implement clearThreadState() and defensive cleanup in intercept() to
prevent ThreadLocal leaks of SentryRecordContext. Spring Kafka calls
clearThreadState() in the poll loop's finally block, making it the
most reliable cleanup hook for edge cases where success()/failure()
callbacks are skipped (e.g. Error thrown by listener).

Also add defensive cleanup at the start of intercept() to handle any
stale context from a previous record that was not properly cleaned up.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): Fork root scopes and skip when OTel is active in Kafka consumer interceptor

Use Sentry.forkedRootScopes() instead of scopes.forkedScopes() so each
Kafka message starts with a clean scope from root, matching the pattern
used by SentryWebFilter for reactive request boundaries.

Add isIgnored() check using SpanUtils.isIgnored() on the trace origin
so the interceptor no-ops when OTel is active and the origin is in the
ignored span origins list, consistent with SentryTracingFilter.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): Guard entire span lifecycle in Kafka producer interceptor

Wrap all span operations (startChild, setData, injectHeaders, finish)
in a single try-catch so instrumentation can never break the customer's
Kafka send. The record is always returned regardless of any exception
in Sentry code.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): [Queue Instrumentation 12] Add Kafka retry count attribute

Set messaging.message.retry.count on queue.process transactions when the Spring Kafka delivery attempt header is present. This keeps retry context on consumer traces without changing transaction lifecycle behavior.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): [Queue Instrumentation 13] Align enqueue time with Python

Store sentry-task-enqueued-time as epoch seconds and compute receive latency from seconds on the consumer side. This aligns Java Kafka queue instrumentation with sentry-python Celery behavior for cross-SDK interoperability.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(kafka): Extract sentry-kafka module from spring-jakarta

Move Kafka producer interceptor to a new sentry-kafka module and rename
to SentryKafkaProducerInterceptor. Add SentryKafkaConsumerInterceptor
for vanilla kafka-clients users. Spring integration now depends on
sentry-kafka and passes a Spring-specific trace origin.

This allows non-Spring applications to use Kafka queue instrumentation
directly via kafka-clients interceptor config.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* feat(kafka): Add no-arg producer interceptor for Kafka config

Allow kafka-clients to instantiate SentryKafkaProducerInterceptor via interceptor.classes by adding a no-arg constructor that uses ScopesAdapter. This makes native Kafka interceptor wiring work out of the box in applications and samples.\n\nAlso add a Kafka tracing example to the console sample with a transaction-scoped producer send, and cover no-arg constructor behavior in sentry-kafka tests.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(kafka): Add consumer demo to console sample

Show end-to-end Kafka queue tracing in the console sample by running a background consumer thread, producing a message, and waiting for consume before exit.\n\nAdd a no-arg constructor to SentryKafkaConsumerInterceptor so kafka-clients can instantiate it from interceptor.classes, and add test coverage for that constructor.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(samples): Extract Kafka console showcase into dedicated class

Move Kafka producer/consumer showcase logic out of Main into KafkaShowcase to make the sample easier to read and follow. Keep runtime behavior unchanged by preserving the same demo entry point and flow.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(samples): Add opt-in Kafka console e2e coverage

Gate the console Kafka showcase behind SENTRY_SAMPLE_KAFKA_BOOTSTRAP_SERVERS so Kafka behavior is enabled only when configured. Keep the showcase isolated in KafkaShowcase and use fail-fast Kafka client timeouts for local runs.\n\nExtend console system tests to assert producer and consumer queue tracing when Kafka is enabled. Update system-test-runner to provision or reuse a local Kafka broker for the console module and clean up runner-managed resources.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(samples): Move KafkaShowcase to kafka subpackage

Move KafkaShowcase under io.sentry.samples.console.kafka and update Main to
import the relocated class.

This keeps Kafka-specific sample code grouped in a dedicated package
without changing runtime behavior.

Co-Authored-By: Claude <noreply@anthropic.com>

* Update KafkaShowcase.java

extract constant

* Update KafkaShowcase.java

extract methods

* Update KafkaShowcase.java

refactor

* Format code

* fix

* ref(samples): Clarify Kafka setup in console showcase

Restructure KafkaShowcase to highlight the required Sentry interceptor
configuration for producer and consumer setups.

Split property construction into explicit helper methods and rename the
entrypoint to make customer integration requirements easier to follow
without changing behavior.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(test): Enable Kafka profile for Spring Kafka system tests

Make the system test runner configure Kafka requirements by module.

Start Kafka and set SPRING_PROFILES_ACTIVE=kafka for modules that need
Kafka-backed Spring endpoints so queue system tests run with the expected
routing and broker configuration.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring): Guard Kafka auto-config on sentry-kafka

Require the sentry-kafka producer interceptor class before activating
Spring Boot Jakarta queue auto-configuration. This keeps sentry-kafka
optional for customers who only use the starter without Kafka queue
tracing support on the classpath.

Add a regression test that hides sentry-kafka from the classloader and
verifies the Kafka bean post-processors are skipped instead of being
registered.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(kafka): [Queue Instrumentation 17] Add manual consumer tracing helper

Add an experimental helper for wrapping raw Kafka consumer record
processing in queue.process transactions. This exposes Kafka consumer
tracing outside interceptor-based integrations.

Capture messaging metadata and distributed tracing context in the
helper so future queue instrumentation can reuse the same behavior.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(kafka): Remove raw consumer interceptor

Remove the raw Kafka consumer interceptor from sentry-kafka and update the console sample to use the manual consumer tracing helper instead. Keep producer tracing on the interceptor path and move consumer tracing to explicit record processing.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(samples): Clarify Kafka consumer tracing sample

Print the consumed Kafka record inside the manual consumer tracing callback so the sample shows where application processing happens. Update the console system test to assert the manual queue.process transaction and its manual consumer origin.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(kafka): Honor ignored producer span origins

Short-circuit the raw Kafka producer interceptor when its trace origin is
configured in ignoredSpanOrigins.

This lets customers disable the integration quickly without relying on the
later no-op span path, and keeps the interceptor from injecting tracing
headers when the origin is ignored.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(spring): Use injected scopes in Kafka interceptor

Stop the Spring Kafka record interceptor from reaching through the
static Sentry API when forking root scopes. This keeps the raw Kafka
and Spring Kafka paths aligned and makes the interceptor easier to test.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(samples): [Queue Instrumentation 18] Move Kafka sources into queues.kafka package

Move KafkaConsumer and KafkaController in the three Spring Boot Jakarta
samples (jakarta, jakarta-opentelemetry, jakarta-opentelemetry-noagent)
into a queues.kafka sub-package.

No behavior change. Groups the Kafka-specific sample sources so future
queue integrations can sit next to them under queues.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(samples): [Queue Instrumentation 19] Drop Kafka auto-config exclude from Spring Boot samples

Remove `spring.autoconfigure.exclude=KafkaAutoConfiguration` from the
default `application.properties` and the matching empty override from
`application-kafka.properties` in the three Spring Boot Jakarta samples.

`spring.autoconfigure.exclude` is a single list property, so overriding
it in a profile replaces the whole list rather than merging. Adding a
sibling `rabbitmq` profile with the same pattern would not compose —
activating one profile would unsilence the other's auto-config.

The `@Profile("kafka")` annotations already on `KafkaConsumer` and
`KafkaController` gate the actual listener container and endpoint, so
no broker connection is attempted when the profile is inactive.
`KafkaAutoConfiguration` still runs and creates an unused
`KafkaTemplate` bean in that case, which is harmless.

Sentry's own Kafka auto-config remains gated on
`sentry.enable-queue-tracing=true`, which is only set in
`application-kafka.properties`, so Sentry instrumentation behavior is
unchanged.

* ref(kafka): [Queue Instrumentation 20] Log Kafka instrumentation failures

Previously `SentryKafkaProducerInterceptor.onSend(...)` and
`SentryKafkaConsumerTracing` silently swallowed any `Throwable` thrown
while instrumenting a Kafka record. That protects customer Kafka I/O
from breakage, but makes instrumentation bugs invisible.

Log each caught `Throwable` to the SDK logger at `SentryLevel.ERROR`
(matching the existing pattern in `RequestPayloadExtractor`) before
continuing the fail-open path:

- `SentryKafkaProducerInterceptor`: producer span creation / header injection
- `SentryKafkaConsumerTracing`: scope fork + `makeCurrent`, transaction
  start, transaction finish

No behavior change for customer callbacks or Kafka send/receive: the
catches still swallow the throwable, they now just surface it via the
SDK's own logger.

`SentryKafkaRecordInterceptor` (Spring) was reviewed and intentionally
left as-is — it does not wrap its instrumentation in `catch (Throwable)`
blocks, so there is nothing silent to log. The `NumberFormatException`
branches on malformed `sentry-task-enqueued-time` headers are expected
input, not instrumentation faults, and remain silent.

* fix(kafka): [Queue Instrumentation 21] Preserve third-party baggage on Kafka producer records

`SentryKafkaProducerInterceptor.injectHeaders(...)` previously removed and
overwrote the outgoing `baggage` header on every record, discarding any
third-party baggage entries already present (e.g. set by another vendor's
instrumentation or the application itself).

Read the existing `baggage` header values off the `ProducerRecord` and
pass them to `TracingUtils.trace(...)`. The downstream
`BaggageHeader.fromBaggageAndOutgoingHeader` preserves non-`sentry-*`
entries in the outgoing header while Sentry continues to own its own
keys.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(spring-boot-jakarta): [Queue Instrumentation 22] Cover spring-kafka class-absence gate

`SentryKafkaQueueConfiguration` in `SentryAutoConfiguration` gates the
Kafka BPPs on both `org.springframework.kafka.core.KafkaTemplate` and
`io.sentry.kafka.SentryKafkaProducerInterceptor` being present on the
classpath. Only the latter was covered by a test.

Add a `FilteredClassLoader(KafkaTemplate::class.java)` test that asserts
neither `SentryKafkaProducerBeanPostProcessor` nor
`SentryKafkaConsumerBeanPostProcessor` is registered when spring-kafka
is missing, even with `sentry.enable-queue-tracing=true`.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): [Queue Instrumentation 23] Install Kafka context before trace setup

Store the lifecycle token in the thread-local context immediately after
makeCurrent() so Spring's failure and clearThreadState callbacks can
always clean it up.

Previously, exceptions from trace continuation or transaction setup could
happen before the context was published, leaving cleanup dependent on
later stale-context handling instead of the normal interceptor callback
path.

* fix(kafka): [Queue Instrumentation 24] Read all baggage headers on consumers

Pass every Kafka baggage header through trace continuation in both the
raw Kafka helper and the Spring Kafka record interceptor.

Previously both consumer paths used lastHeader("baggage"), which dropped
all earlier baggage values and could break interop with upstream OTel or
other W3C baggage producers. Reading the full header list preserves the
existing baggage context during queue trace continuation.

* fix(kafka): [Queue Instrumentation 25] Finish producer spans on failures

Keep a local producer child span reference and always finish it when
instrumentation fails after span creation. This preserves fail-open send
behavior without leaking unfinished queue.publish spans.

Add a regression test covering header injection failures.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(kafka): [Queue Instrumentation 26] Mark producer interceptor experimental

The raw kafka producer path requires customers to reference
SentryKafkaProducerInterceptor directly by class name, so it should not be
marked internal. Align it with the customer-facing queue tracing surface by
marking it experimental instead.

Audit the remaining Kafka classes still marked internal and keep them as-is:
the Spring bean post processors and Spring record interceptor remain
framework wiring internals rather than direct customer entry points.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): [Queue Instrumentation 27] Delegate Kafka record thread-state hooks

SentryKafkaRecordInterceptor wraps an existing customer RecordInterceptor
when one is present on the listener container factory, but it previously
only delegated intercept, success, failure, and afterRecord.

setupThreadState was not overridden, so the default no-op from
ThreadStateProcessor shadowed any delegate implementation. clearThreadState
performed Sentry cleanup but never forwarded to the delegate either.

Customers relying on these hooks for MDC, security context, or other
thread-local state on Kafka listener threads would silently lose that
behavior once Sentry auto-wrapped their interceptor.

Delegate setupThreadState to the wrapped interceptor, and in
clearThreadState run Sentry cleanup inside try and delegate to the wrapped
interceptor in finally so delegate cleanup still executes if Sentry
cleanup throws.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(samples): Cover OTel Jakarta Kafka coexistence end-to-end

Enable the Kafka Spring profile (and Kafka broker) for the two OTel Spring
Boot 3 Jakarta sample modules in the system-test runner, and add a Kafka
system test in each that produces a message and asserts no Sentry-style
`queue.publish` / `queue.process` span/transaction is emitted.

SentryKafkaQueueConfiguration is guarded by
@ConditionalOnMissingClass("io.sentry.opentelemetry.SentryAutoConfigurationCustomizerProvider"),
so the Sentry Kafka bean post-processors must not be wired when the Sentry
OTel integration is present. The new assertions lock that suppression into
CI for both the agent and noagent OTel Jakarta samples.

Addresses review finding F-011.

* fix(spring-jakarta): [Queue Instrumentation 29] Set body_size on Spring Kafka consumer transaction

The Spring Kafka consumer path (`SentryKafkaRecordInterceptor`) never set
`messaging.message.body_size`, while the raw Kafka consumer helper
(`SentryKafkaConsumerTracing`) already sets it from
`ConsumerRecord#serializedValueSize()`.

Both are first-party Kafka consumer integrations shipped in the same
stack and should emit the same messaging schema so dashboards and
queries remain consistent across Spring vs. raw Kafka setups.

Mirror the raw helper: set `SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE`
on the `queue.process` transaction when `serializedValueSize() >= 0`.
Add regression tests for both the positive and the -1 (unknown) cases.

#skip-changelog

* test(spring-jakarta): [Queue Instrumentation 30] Cover Kafka record interceptor lifecycle edge cases

Add three regression tests for SentryKafkaRecordInterceptor that pin down
the lifecycle contract around clearThreadState cleanup:

- full lifecycle intercept -> success -> clearThreadState closes the
  lifecycle token exactly once and does not double-finish the transaction
- when a delegating interceptor returns null from intercept (filtering
  the record), the safety net in clearThreadState still finishes the
  transaction and closes the token
- when a delegating interceptor throws from intercept, clearThreadState
  still finishes the transaction and closes the token after the
  exception has propagated

Addresses review finding R6-F001.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(kafka): [Queue Instrumentation 31] Write enqueued-time header as plain decimal

The sentry-task-enqueued-time Kafka header was serialized via
String.valueOf(double), which emits scientific notation (e.g.
1.776933649613E9) for epoch-seconds values. Cross-SDK consumers
(sentry-python, -ruby, -php, -dotnet) expect a plain decimal like
1776938295.692000 and could not parse the Java output, defeating the
cross-SDK alignment goal of #5283.

Route the value through DateUtils.doubleToBigDecimal(...).toString(),
the same helper already used to serialize epoch-seconds timestamps in
SentryTransaction, SentrySpan, SentryLogEvent, etc. At the pinned scale
of 6, BigDecimal.toString() produces plain decimal form for all
realistic epoch-seconds magnitudes.

Add regression assertions that reject scientific notation and pin the
plain-decimal format in SentryKafkaProducerInterceptorTest.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* test(spring-boot-jakarta): [Queue Instrumentation 32] Filter OTel in Kafka auto-config negative tests

The regression tests "does not register Kafka BPPs when sentry-kafka is
not present" and "...when spring-kafka is not present" previously
passed for the wrong reason: OTel's SentryAutoConfigurationCustomizerProvider
is on the test classpath as a testImplementation dependency, so the
@ConditionalOnMissingClass(OTel) gate on SentryKafkaQueueConfiguration
was already blocking the beans independent of the @ConditionalOnClass
check the tests were meant to validate.

Make noSentryKafkaClassLoader and noSpringKafkaClassLoader additionally
filter SentryAutoConfigurationCustomizerProvider so only the gate under
test can be the blocker. Verified by temporarily removing
SentryKafkaProducerInterceptor from the @ConditionalOnClass list: the
test now correctly fails, proving it actually guards against the
regression it is named for.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(opentelemetry): [Queue Instrumentation 33] Map OTel messaging spans to Sentry queue ops

Wire OTel messaging spans into the Sentry Queues product when
`sentry.enable-queue-tracing=true` so OTel-only setups (e.g. the
agentless Spring Boot Jakarta sample) populate queue dashboards without
needing the Sentry-native Kafka interceptors.

`SpanDescriptionExtractor` now recognizes spans carrying
`messaging.system` and maps them to `queue.publish` / `queue.process` /
`queue.receive` ops, using the destination name as the description and
`TransactionNameSource.TASK`. Op selection prefers
`messaging.operation.type` (current OTel semconv), falls back to the
deprecated `messaging.operation`, and only as a last resort consults
`SpanKind` — `SpanKind.CONSUMER` is overloaded for both `receive` and
`process`, so attribute-driven mapping is required to disambiguate. The
extractor takes `SentryOptions` so the mapping stays gated; when the
flag is off, behavior is unchanged.

`SentrySpanExporter` additionally transfers the messaging attributes
(`system`, `destination.name`, `operation.type`, `message.id`,
`message.body.size`, `message.envelope.size`) onto root transactions.
Root transactions don't bulk-copy OTel attributes the way child spans
do, but the Queues product reads `trace.data.messaging.*`, so consumer
root transactions need them propagated explicitly. These are operational
metadata only (no payload contents), so the transfer is unconditional.

Add `MESSAGING_OPERATION_TYPE` and `MESSAGING_MESSAGE_ENVELOPE_SIZE` to
`SpanDataConvention` for use by the exporter and downstream
integrations. Document the OTel-mode behavior in the two Jakarta OTel
sample `application-kafka.properties` so users know the flag activates
the OTel remapping path here, not the Sentry-native Kafka auto-config
(which stays suppressed by its `@ConditionalOnMissingClass` OTel guard).

* fix(otel): Prefer messaging over http mapping when queue tracing enabled

Some OTel instrumentations (notably aws-sdk-2.2 SQS) attach both
`http.request.method` and `messaging.system` to the same span. With the
previous gate order, those spans resolved to http.client and the Sentry
Queues product never lit up for one of the most common OTel-coexistence
targets.

When `enableQueueTracing` is true and `messaging.system` is present, map
to a queue.* op before the http and db checks. When the flag is off, the
existing http-first ordering is preserved.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(otel): Map messaging "create" to queue.create instead of queue.publish

The OTel messaging semconv defines "create" and "publish" as distinct
operations: "create" represents message construction, "publish" the
network send. Folding both into queue.publish risks double-counting
producer transactions on instrumentations that emit a separate create
span (per OTel semconv guidance).

Per the Sentry Queues telemetry spec
(https://develop.sentry.dev/sdk/telemetry/traces/modules/queues/),
queue.create is a canonical op distinct from queue.publish, so map
"create" to its spec-correct destination rather than dropping it.

Empirically, current Kafka OTel instrumentation does not emit a
separate create span, so this is a no-op for Kafka users today; the
change future-proofs other systems and any future Kafka OTel version.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs(options): Clarify enableQueueTracing covers native + OTel paths

The setEnableQueueTracing Javadoc said only "Whether queue operations
(publish, process) should be traced." — silent on the fact that the
flag also drives OTel messaging-span transformation when
sentry-opentelemetry is on the classpath.

Reword on both the getter and setter to make explicit that the flag
both emits Sentry-native queue spans and transforms OTel messaging
spans to match Sentry's queue conventions, so customers grepping
their IDE see what the flag does in either integration mode.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(otel): Map messaging "settle" to queue.settle

OTel messaging semconv defines messaging.operation.type=settle for
consumer ack/nack/reject spans (JMS, RabbitMQ, Pulsar acknowledge).
The switch had no case for "settle", so settle spans on
SpanKind.CONSUMER were falling through to the SpanKind fallback and
becoming queue.process — duplicating the real process span — while
on SpanKind.CLIENT they became the generic "queue" default.

queue.settle is one of the canonical Queues telemetry ops per
https://develop.sentry.dev/sdk/telemetry/traces/modules/queues/, so
add the explicit mapping.

Co-Authored-By: Claude <noreply@anthropic.com>

* chore(samples): Drop verbose comment above sentry.enable-queue-tracing

The OTel Kafka sample properties carried a 10-line comment explaining
the OTel->Sentry remapping mechanism and SentryKafkaQueueConfiguration
suppression behavior. That belongs in the SDK docs, not in a sample
config — drop it so the property line speaks for itself.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(kafka): [Queue Instrumentation 34] Wrap Producer for send spans

Replace SentryKafkaProducerInterceptor with SentryKafkaProducer, a
Producer<K,V> wrapper that records a queue.publish span around each
send and finishes it when the broker ack callback fires. The span
now reflects the full async send lifecycle, not just the synchronous
onSend window.

For Spring Boot, the SentryKafkaProducerBeanPostProcessor switches
from patching KafkaTemplate.setProducerInterceptor(...) to installing
a ProducerPostProcessor on every ProducerFactory bean via
ProducerFactory.addPostProcessor(...). KafkaTemplate beans are no
longer touched, so all customer-configured listeners, interceptors
and observation settings are preserved.

The console sample now wraps the raw KafkaProducer instead of setting
INTERCEPTOR_CLASSES_CONFIG. Spring Boot samples need no change — the
auto-configured ProducerPostProcessor is transparent.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(kafka): Inject trace headers even without active span

Decouple header injection from span creation in SentryKafkaProducer
so that distributed tracing works for background workers, @Scheduled
jobs, and startup publishers that have no active span.

Restructure send() to match the SentryFeignClient/OkHttp pattern:
- isIgnored: pure delegate, no headers, no span
- No active span: inject headers from PropagationContext, no span
- Active span: start child span, inject headers, wrap callback

Also simplify the implementation:
- Rename injectHeaders to maybeInjectHeaders with encapsulated
  try/catch (matches Feign's maybeAddTracingHeaders pattern)
- Remove outer try/catch around span setup
- Remove redundant span.isNoOp() early-return branch
- Remove redundant isFinished() guards before finish() calls

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* ref(kafka): Reimplement SentryKafkaProducer as a dynamic Proxy

Replace the concrete `implements Producer<K,V>` class with a
`Proxy.newProxyInstance`-based wrapper that intercepts only the two
`send()` overloads and forwards every other method reflectively to
the delegate.

The concrete class required explicitly delegating every method on the
`Producer` interface, coupling the wrapper to a specific Kafka version:
`clientInstanceId(Duration)` was added in Kafka 3.7, and the deprecated
`sendOffsetsToTransaction(Map, String)` was removed in Kafka 4.0. The
dynamic proxy has no such coupling — new or removed interface methods are
handled automatically, giving full compatibility across all Kafka
client versions.

Public API change: `SentryKafkaProducer` is now a utility class with
static `wrap()` overloads instead of constructors. Callers wrap a
producer with `SentryKafkaProducer.wrap(producer)`. The Spring BPP and
console sample are updated accordingly.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-jakarta): Warn when Kafka producer tracing silently fails

When ProducerFactory.addPostProcessor() is a no-op (the interface
default), the Sentry post-processor is silently dropped and the
customer gets zero producer tracing with no signal.

Verify registration succeeded via getPostProcessors() after each
addPostProcessor() call, and log a WARNING naming the factory bean
and pointing toward SentryKafkaProducer.wrap() as the manual fallback.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(kafka): Preserve existing consumer interceptor on reflection failure

If reading recordInterceptor via reflection fails, leave the container\nfactory untouched instead of installing Sentry's interceptor with a\nnull delegate. This avoids silently dropping customer-configured\ninterceptors for DLQ routing, auditing, or other message handling\nconcerns.\n\nAdd tests that preserve customer interceptors both when chaining\nsucceeds and when reflection cannot safely determine the existing\ninterceptor.\n\nCo-Authored-By: Claude <noreply@anthropic.com>

* fix(spring-boot-jakarta): Skip Kafka autoconfig for OTel agent

* fix(spring-jakarta): Close leaked Kafka interceptor scope

Store the lifecycle token in the thread-local before trace continuation or transaction startup can throw. This keeps the cleanup path reachable and closes the forked scopes even when interceptor preparation fails.

Also log the preparation failure instead of letting the interceptor break customer processing.

* fix(test): Remove stale Kafka container before startup

Always remove the named Kafka system-test container before starting a new broker. This avoids docker name conflicts after crashed or interrupted runs while still keeping stop_kafka_broker ownership-aware for reused brokers.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(otel): Add send and deliver mapping coverage

* test(kafka): Add no-op producer span coverage

* fix(kafka): Pass consumer interceptor log throwable correctly

* test(kafka): Exercise consumer interceptor reflection failure

Force the reflection-failure path in the consumer bean post processor test so it proves customer interceptors remain untouched when Sentry skips installation.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(test): Set SENTRY_ENABLE_QUEUE_TRACING for Kafka system tests

When SENTRY_AUTO_INIT=true with the OTel agent, Sentry is initialized
early by SentryAutoConfigurationCustomizerProvider before Spring Boot
loads application-kafka.properties. Without the env var, queue tracing
stays disabled and OTel messaging spans are not mapped to
queue.publish/queue.process ops, causing
KafkaOtelCoexistenceSystemTest to fail.

Co-Authored-By: Claude <noreply@anthropic.com>

* feat(spring): Add Kafka queue tracing for Spring Boot 4

Port the Spring Boot 3 Kafka queue tracing support to the Spring 7 and Spring Boot 4 modules.

Add Spring Kafka bean post-processors, Boot 4 auto-configuration, and matching sample system-test coverage.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* feat(spring): Add Kafka queue tracing for Spring Boot 2

Port Kafka queue tracing to the Spring and Spring Boot 2 modules.

Add Spring Kafka bean post-processors, Boot 2 auto-configuration, and matching sample system-test coverage.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs(rules): Add queue tracing cursor rules

Document when to load queue-specific Cursor rules and summarize how Sentry Queues data is produced by the Java SDK Kafka instrumentation.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* build(samples): Use Spring Boot Kafka starter in Boot 4 samples

* fix(queue): Apply queue instrumentation review changes

* test(spring): Address Kafka tracing review comments

Simplify Kafka interceptor test delegates and rely on Kotlin type inference in Spring Kafka tests.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(spring): Initialize Sentry in Kafka BPP tests

Initialize Sentry before each Kafka bean post-processor test and close it afterwards so logging paths do not depend on test execution order. This prevents failures when earlier tests close the SDK before these tests run.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(spring): Address Kafka review comments

Simplify Spring Kafka test interceptors and cover intercepting records without a consumer.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(spring): Isolate capture exception advice scopes

Initialize Sentry before installing the mocked scopes used by the capture exception parameter advice test. Close Sentry after the test so the mocked scopes do not leak into later tests.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog entry

* fix README changes

* test(otel): Relax Kafka coexistence span assertion

Avoid requiring the async Kafka producer span to be embedded in the HTTP transaction. OTel can finish and export the producer span after the request transaction, so this assertion flakes while the test still verifies OTel instrumentation suppresses Spring Kafka integration.

Refs #5373

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(kafka): Make producer proxy equality reflexive

Return true when the Kafka producer proxy is compared with itself. This preserves existing delegate equality behavior for other comparisons while satisfying the equals contract.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 .cursor/rules/overview_dev.mdc                |  10 +
 .cursor/rules/pr.mdc                          |   2 +
 .cursor/rules/queues.mdc                      |  82 +++
 CHANGELOG.md                                  |  10 +
 README.md                                     |   1 +
 buildSrc/src/main/java/Config.kt              |   1 +
 gradle/libs.versions.toml                     |   5 +
 sentry-kafka/README.md                        |   5 +
 sentry-kafka/api/sentry-kafka.api             |  19 +
 sentry-kafka/build.gradle.kts                 |  83 +++
 .../kafka/SentryKafkaConsumerTracing.java     | 280 ++++++++++
 .../io/sentry/kafka/SentryKafkaProducer.java  | 265 ++++++++++
 .../kafka/SentryKafkaConsumerTracingTest.kt   | 254 +++++++++
 .../sentry/kafka/SentryKafkaProducerTest.kt   | 375 ++++++++++++++
 .../api/sentry-opentelemetry-core.api         |   2 +-
 .../opentelemetry/SentrySpanExporter.java     |  18 +-
 .../opentelemetry/SentrySpanProcessor.java    |   4 +-
 .../SpanDescriptionExtractor.java             |  61 ++-
 .../kotlin/SpanDescriptionExtractorTest.kt    | 251 ++++++++-
 .../sentry-samples-console/build.gradle.kts   |   2 +
 .../java/io/sentry/samples/console/Main.java  |  13 +
 .../samples/console/kafka/KafkaShowcase.java  | 143 ++++++
 .../ConsoleApplicationSystemTest.kt           |  49 +-
 .../build.gradle.kts                          |   4 +
 .../boot4/queues/kafka/KafkaConsumer.java     |  19 +
 .../boot4/queues/kafka/KafkaController.java   |  26 +
 .../resources/application-kafka.properties    |  12 +
 .../KafkaOtelCoexistenceSystemTest.kt         |  37 ++
 .../build.gradle.kts                          |   4 +
 .../boot4/queues/kafka/KafkaConsumer.java     |  19 +
 .../boot4/queues/kafka/KafkaController.java   |  26 +
 .../resources/application-kafka.properties    |  12 +
 .../KafkaOtelCoexistenceSystemTest.kt         |  37 ++
 .../build.gradle.kts                          |   4 +
 .../boot4/queues/kafka/KafkaConsumer.java     |  19 +
 .../boot4/queues/kafka/KafkaController.java   |  26 +
 .../resources/application-kafka.properties    |  10 +
 .../sentry/systemtest/KafkaQueueSystemTest.kt | 117 +++++
 .../build.gradle.kts                          |   4 +
 .../jakarta/queues/kafka/KafkaConsumer.java   |  19 +
 .../jakarta/queues/kafka/KafkaController.java |  26 +
 .../resources/application-kafka.properties    |  12 +
 .../KafkaOtelCoexistenceSystemTest.kt         |  37 ++
 .../build.gradle.kts                          |   4 +
 .../jakarta/queues/kafka/KafkaConsumer.java   |  19 +
 .../jakarta/queues/kafka/KafkaController.java |  26 +
 .../resources/application-kafka.properties    |  12 +
 .../KafkaOtelCoexistenceSystemTest.kt         |  37 ++
 .../build.gradle.kts                          |   4 +
 .../jakarta/queues/kafka/KafkaConsumer.java   |  19 +
 .../jakarta/queues/kafka/KafkaController.java |  26 +
 .../resources/application-kafka.properties    |  10 +
 .../src/main/resources/application.properties |   1 +
 .../sentry/systemtest/KafkaQueueSystemTest.kt | 117 +++++
 .../build.gradle.kts                          |   4 +
 .../boot/queues/kafka/KafkaConsumer.java      |  19 +
 .../boot/queues/kafka/KafkaController.java    |  26 +
 .../resources/application-kafka.properties    |  12 +
 .../KafkaOtelCoexistenceSystemTest.kt         |  37 ++
 .../build.gradle.kts                          |   4 +
 .../boot/queues/kafka/KafkaConsumer.java      |  19 +
 .../boot/queues/kafka/KafkaController.java    |  26 +
 .../resources/application-kafka.properties    |  12 +
 .../KafkaOtelCoexistenceSystemTest.kt         |  37 ++
 .../build.gradle.kts                          |   4 +
 .../boot/queues/kafka/KafkaConsumer.java      |  19 +
 .../boot/queues/kafka/KafkaController.java    |  26 +
 .../resources/application-kafka.properties    |  10 +
 .../sentry/systemtest/KafkaQueueSystemTest.kt | 117 +++++
 sentry-spring-7/api/sentry-spring-7.api       |  23 +
 sentry-spring-7/build.gradle.kts              |   4 +
 .../SentryKafkaConsumerBeanPostProcessor.java |  98 ++++
 .../SentryKafkaProducerBeanPostProcessor.java |  76 +++
 .../kafka/SentryKafkaRecordInterceptor.java   | 292 +++++++++++
 ...entryKafkaConsumerBeanPostProcessorTest.kt | 124 +++++
 ...entryKafkaProducerBeanPostProcessorTest.kt | 109 ++++
 .../kafka/SentryKafkaRecordInterceptorTest.kt | 473 +++++++++++++++++
 sentry-spring-boot-4/build.gradle.kts         |   3 +
 .../spring/boot4/SentryAutoConfiguration.java |  30 ++
 .../boot4/SentryKafkaAutoConfigurationTest.kt | 125 +++++
 sentry-spring-boot-jakarta/build.gradle.kts   |   3 +
 .../boot/jakarta/SentryAutoConfiguration.java |  30 ++
 .../SentryKafkaAutoConfigurationTest.kt       | 125 +++++
 sentry-spring-boot/build.gradle.kts           |   4 +
 .../spring/boot/SentryAutoConfiguration.java  |  30 ++
 .../boot/SentryKafkaAutoConfigurationTest.kt  | 125 +++++
 .../api/sentry-spring-jakarta.api             |  23 +
 sentry-spring-jakarta/build.gradle.kts        |   4 +
 .../SentryKafkaConsumerBeanPostProcessor.java |  98 ++++
 .../SentryKafkaProducerBeanPostProcessor.java |  76 +++
 .../kafka/SentryKafkaRecordInterceptor.java   | 292 +++++++++++
 ...entryKafkaConsumerBeanPostProcessorTest.kt | 124 +++++
 ...entryKafkaProducerBeanPostProcessorTest.kt | 109 ++++
 .../kafka/SentryKafkaRecordInterceptorTest.kt | 476 +++++++++++++++++
 sentry-spring/api/sentry-spring.api           |  24 +
 sentry-spring/build.gradle.kts                |   4 +
 .../SentryKafkaConsumerBeanPostProcessor.java |  98 ++++
 .../SentryKafkaProducerBeanPostProcessor.java |  76 +++
 .../kafka/SentryKafkaRecordInterceptor.java   | 298 +++++++++++
 ...ntryCaptureExceptionParameterAdviceTest.kt |   9 +
 ...entryKafkaConsumerBeanPostProcessorTest.kt | 110 ++++
 ...entryKafkaProducerBeanPostProcessorTest.kt |  95 ++++
 .../kafka/SentryKafkaRecordInterceptorTest.kt | 486 ++++++++++++++++++
 .../sentry/systemtest/util/RestTestClient.kt  |   6 +
 sentry/api/sentry.api                         |  12 +
 .../main/java/io/sentry/ExternalOptions.java  |  11 +
 .../main/java/io/sentry/SentryOptions.java    |  26 +
 .../java/io/sentry/SpanDataConvention.java    |   8 +
 .../main/java/io/sentry/util/SpanUtils.java   |   4 +
 .../java/io/sentry/ExternalOptionsTest.kt     |  14 +
 .../test/java/io/sentry/SentryOptionsTest.kt  |  22 +
 settings.gradle.kts                           |   1 +
 test/system-test-runner.py                    | 124 +++++
 113 files changed, 7335 insertions(+), 21 deletions(-)
 create mode 100644 .cursor/rules/queues.mdc
 create mode 100644 sentry-kafka/README.md
 create mode 100644 sentry-kafka/api/sentry-kafka.api
 create mode 100644 sentry-kafka/build.gradle.kts
 create mode 100644 sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaConsumerTracing.java
 create mode 100644 sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaProducer.java
 create mode 100644 sentry-kafka/src/test/kotlin/io/sentry/kafka/SentryKafkaConsumerTracingTest.kt
 create mode 100644 sentry-kafka/src/test/kotlin/io/sentry/kafka/SentryKafkaProducerTest.kt
 create mode 100644 sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/kafka/KafkaShowcase.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/resources/application-kafka.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/resources/application-kafka.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4/src/main/resources/application-kafka.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/resources/application-kafka.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/resources/application-kafka.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application-kafka.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/resources/application-kafka.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/resources/application-kafka.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
 create mode 100644 sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java
 create mode 100644 sentry-samples/sentry-samples-spring-boot/src/main/resources/application-kafka.properties
 create mode 100644 sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt
 create mode 100644 sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaConsumerBeanPostProcessor.java
 create mode 100644 sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaProducerBeanPostProcessor.java
 create mode 100644 sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaRecordInterceptor.java
 create mode 100644 sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt
 create mode 100644 sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaProducerBeanPostProcessorTest.kt
 create mode 100644 sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaRecordInterceptorTest.kt
 create mode 100644 sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryKafkaAutoConfigurationTest.kt
 create mode 100644 sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryKafkaAutoConfigurationTest.kt
 create mode 100644 sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryKafkaAutoConfigurationTest.kt
 create mode 100644 sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaConsumerBeanPostProcessor.java
 create mode 100644 sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaProducerBeanPostProcessor.java
 create mode 100644 sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaRecordInterceptor.java
 create mode 100644 sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt
 create mode 100644 sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaProducerBeanPostProcessorTest.kt
 create mode 100644 sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaRecordInterceptorTest.kt
 create mode 100644 sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaConsumerBeanPostProcessor.java
 create mode 100644 sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaProducerBeanPostProcessor.java
 create mode 100644 sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaRecordInterceptor.java
 create mode 100644 sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt
 create mode 100644 sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaProducerBeanPostProcessorTest.kt
 create mode 100644 sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaRecordInterceptorTest.kt

diff --git a/.cursor/rules/overview_dev.mdc b/.cursor/rules/overview_dev.mdc
index 17ce98f07be..b837be34add 100644
--- a/.cursor/rules/overview_dev.mdc
+++ b/.cursor/rules/overview_dev.mdc
@@ -66,6 +66,15 @@ Use the `fetch_rules` tool to include these rules when working on specific areas
   - `SentryMetricsEvent`, `SentryMetricsEvents`
   - `SentryOptions.getMetrics()`, `beforeSend` callback
 
+- **`queues`**: Use when working with:
+  - Sentry Queues product data or messaging span conventions
+  - Queue tracing spans/transactions (`queue.publish`, `queue.process`)
+  - `enableQueueTracing` option and `sentry.enable-queue-tracing`
+  - Kafka instrumentation (`sentry-kafka`, `SentryKafkaProducer`, `SentryKafkaConsumerTracing`)
+  - Spring Kafka queue auto-instrumentation and `SentryKafkaRecordInterceptor`
+  - Messaging span data (`messaging.system`, `messaging.destination.name`, receive latency, retry count)
+  - `sentry-task-enqueued-time` header and distributed trace propagation through queues
+
 - **`continuous_profiling_jvm`**: Use when working with:
   - JVM continuous profiling (`sentry-async-profiler` module)
   - `IContinuousProfiler`, `JavaContinuousProfiler`
@@ -118,6 +127,7 @@ Use the `fetch_rules` tool to include these rules when working on specific areas
    - System test/e2e/sample → `e2e_tests`
    - Feature flag/addFeatureFlag/flag evaluation → `feature_flags`
    - Metrics/count/distribution/gauge → `metrics`
+   - Queues/queue tracing/Kafka/Spring Kafka/queue.publish/queue.process/enableQueueTracing/messaging spans → `queues`
    - PR/pull request/stacked PR/stack → `pr`
    - JVM continuous profiling/async-profiler/JFR/ProfileChunk → `continuous_profiling_jvm`
    - Android continuous profiling/AndroidProfiler/frame metrics/method tracing → no dedicated rule yet; inspect the code directly
diff --git a/.cursor/rules/pr.mdc b/.cursor/rules/pr.mdc
index 08a07511c67..e15c0a0a563 100644
--- a/.cursor/rules/pr.mdc
+++ b/.cursor/rules/pr.mdc
@@ -258,3 +258,5 @@ git push
 **Never merge into the collection branch.** Syncing only happens between stack PR branches. The collection branch is untouched until the user merges PRs through GitHub.
 
 Prefer merge over rebase — it preserves commit history, doesn't invalidate existing review comments, and avoids the need for force-pushing. Only rebase if explicitly requested.
+
+**Never amend or force-push stack branches.** Do not use `git commit --amend`, `--force`, or `--force-with-lease` on branches that are part of a stack. Amending a pushed commit requires a force-push, which can cause GitHub to auto-merge or auto-close other PRs in the stack. If a commit needs fixing, add a new fixup commit instead.
diff --git a/.cursor/rules/queues.mdc b/.cursor/rules/queues.mdc
new file mode 100644
index 00000000000..fe082c3b854
--- /dev/null
+++ b/.cursor/rules/queues.mdc
@@ -0,0 +1,82 @@
+---
+alwaysApply: false
+description: Sentry Queues module and Java SDK queue tracing
+---
+# Sentry Queues and Java SDK Queue Tracing
+
+## Product model
+
+Sentry Queues is built from tracing data. SDKs mark queue work with queue-specific span operations and messaging span data so Sentry can identify producers, consumers, destinations, latency, and failures.
+
+The important concepts are:
+- `queue.publish`: a span for enqueueing/publishing a message to a queue or topic.
+- `queue.process`: a transaction for processing a dequeued message.
+- Messaging span data, especially:
+  - `messaging.system` (for example `kafka`)
+  - `messaging.destination.name` (queue/topic name)
+  - `messaging.message.id`
+  - `messaging.message.retry.count`
+  - `messaging.message.body.size`
+  - `messaging.message.envelope.size`
+  - `messaging.message.receive.latency`
+- Distributed tracing headers (`sentry-trace` and `baggage`) link producer-side work to consumer-side processing.
+- Queue receive latency is the time a message spent waiting between publish/enqueue and processing. For Java Kafka, this comes from the `sentry-task-enqueued-time` header that the producer writes and the consumer reads.
+
+The Queues UI is not backed by a separate Java event type. The Java SDK contributes data through spans/transactions with the expected operations, trace context, statuses, and messaging attributes.
+
+## Java SDK implementation
+
+Queue tracing is opt-in. `SentryOptions.isEnableQueueTracing()` defaults to `false` and can be enabled with `setEnableQueueTracing(true)` or external config key `enable-queue-tracing` (`sentry.enable-queue-tracing` in Spring Boot). Captured queue spans/transactions still depend on tracing being enabled and sampled.
+
+Kafka support lives in `sentry-kafka`:
+- `SentryKafkaProducer.wrap(Producer)` wraps Kafka `Producer.send(...)` calls.
+  - Creates a `queue.publish` child span when there is an active span.
+  - Sets `messaging.system=kafka` and `messaging.destination.name=<topic>`.
+  - Injects `sentry-trace`, `baggage`, and `sentry-task-enqueued-time` headers.
+  - Still injects tracing/enqueued-time headers when queue tracing is enabled but there is no active span, so background producers can link to consumers.
+  - Finishes the span from the Kafka callback with `OK` or `INTERNAL_ERROR`.
+- `SentryKafkaConsumerTracing.withTracing(record, callback)` is the manual raw-Kafka consumer helper.
+  - Forks root scopes for the processing lifecycle and makes them current.
+  - Continues the trace from Kafka headers.
+  - Starts a `queue.process` transaction bound to scope when tracing is enabled.
+  - Sets Kafka messaging data, body size, retry count, and receive latency when available.
+  - Finishes with `OK` or `INTERNAL_ERROR` and never lets instrumentation failures break customer processing.
+
+Spring Kafka support lives in `sentry-spring`, `sentry-spring-jakarta`, and `sentry-spring-7`:
+- `SentryKafkaProducerBeanPostProcessor` installs a producer post-processor on `DefaultKafkaProducerFactory` and wraps created producers with `SentryKafkaProducer.wrap(...)`.
+- `SentryKafkaConsumerBeanPostProcessor` installs `SentryKafkaRecordInterceptor` on listener container factories.
+- `SentryKafkaRecordInterceptor` starts/finishes `queue.process` transactions around listener processing, continues traces from headers, forks scopes for the record lifecycle, and preserves any existing delegate interceptor.
+- Spring Boot auto-configuration registers both post-processors only when Spring Kafka and `sentry-kafka` are present and `sentry.enable-queue-tracing=true`.
+- Spring Boot queue auto-configuration is disabled when Sentry OpenTelemetry integration classes are present to avoid duplicate Kafka instrumentation.
+
+## Trace origins and suppression
+
+Queue instrumentation sets span origins so it can be identified and suppressed with `ignoredSpanOrigins`:
+- Raw Kafka producer: `auto.queue.kafka.producer`
+- Raw Kafka consumer helper: `manual.queue.kafka.consumer`
+- Spring Kafka producer: `auto.queue.spring.kafka.producer`, `auto.queue.spring_jakarta.kafka.producer`, `auto.queue.spring7.kafka.producer`
+- Spring Kafka consumer: `auto.queue.spring.kafka.consumer`, `auto.queue.spring_jakarta.kafka.consumer`, `auto.queue.spring7.kafka.consumer`
+
+## Files to inspect when changing queue tracing
+
+- Core option and conventions:
+  - `sentry/src/main/java/io/sentry/SentryOptions.java`
+  - `sentry/src/main/java/io/sentry/ExternalOptions.java`
+  - `sentry/src/main/java/io/sentry/SpanDataConvention.java`
+- Raw Kafka:
+  - `sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaProducer.java`
+  - `sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaConsumerTracing.java`
+  - `sentry-kafka/src/test/kotlin/io/sentry/kafka/*Test.kt`
+- Spring Kafka:
+  - `sentry-spring*/src/main/java/io/sentry/**/kafka/*`
+  - `sentry-spring*/src/test/kotlin/io/sentry/**/kafka/*Test.kt`
+  - `sentry-spring-boot*/src/main/java/io/sentry/**/SentryAutoConfiguration.java`
+  - `sentry-spring-boot*/src/test/kotlin/io/sentry/**/SentryKafkaAutoConfigurationTest.kt`
+
+## Related rules
+
+Also fetch:
+- `options` when changing `enableQueueTracing` or configuration surfaces.
+- `scopes` when changing consumer scope forking/lifecycle.
+- `opentelemetry` when changing coexistence with OTel auto-instrumentation.
+- `api` when changing public Kafka APIs or option methods.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9b945938d2b..244d229b994 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,16 @@
     .configurator { it.isUseShakeGesture = true }
     .create()
   ```
+- Add support for Kafka ([#5249](https://github.com/getsentry/sentry-java/pull/5249))
+  - You will need to add the `sentry-kafka` dependency and opt-in via the new option.
+    - Set `options.setEnableQueueTracing(true)` on `Sentry.init`
+    - Or set `sentry.enable-queue-tracing=true` in `application.properties`
+  - For Spring Boot Kafka is auto instrumented and no further configuration is needed.
+    - also see https://docs.sentry.io/platforms/java/guides/spring-boot/integrations/kafka/
+  - When using `kafka-clients` directly
+    - you need to wrap your `KafkaProducer` via `SentryKafkaProducer.wrap(kafkaProducer)` to get `queue.publish` spans
+    - and you may use our `SentryKafkaConsumerTracing.withTracing` helper to instrument the consumer side manually.
+    - also see https://docs.sentry.io/platforms/java/integrations/kafka/
 
 ### Fixes
 
diff --git a/README.md b/README.md
index 7d9ad7ba287..9aaf7aca4d8 100644
--- a/README.md
+++ b/README.md
@@ -35,6 +35,7 @@ Sentry SDK for Java and Android
 | sentry                                  | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry)                                  | 21 |
 | sentry-jul                              | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-jul?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-jul)                              |
 | sentry-jdbc                             | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-jdbc?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-jdbc)                             |
+| sentry-kafka                            | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-kafka?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-kafka)                            |
 | sentry-apollo                           | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apollo?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-apollo)                           | 21 |
 | sentry-apollo-3                         | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apollo-3?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-apollo-3)                         | 21 |
 | sentry-apollo-4                         | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-apollo-4?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-apollo-4)                         | 21 |
diff --git a/buildSrc/src/main/java/Config.kt b/buildSrc/src/main/java/Config.kt
index 3285db23a98..3410d9601d3 100644
--- a/buildSrc/src/main/java/Config.kt
+++ b/buildSrc/src/main/java/Config.kt
@@ -80,6 +80,7 @@ object Config {
         val SENTRY_JCACHE_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.jcache"
         val SENTRY_QUARTZ_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.quartz"
         val SENTRY_JDBC_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.jdbc"
+        val SENTRY_KAFKA_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.kafka"
         val SENTRY_OPENFEATURE_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.openfeature"
         val SENTRY_LAUNCHDARKLY_SERVER_SDK_NAME = "$SENTRY_JAVA_SDK_NAME.launchdarkly-server"
         val SENTRY_LAUNCHDARKLY_ANDROID_SDK_NAME = "$SENTRY_ANDROID_SDK_NAME.launchdarkly"
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index cf7bc7b4f32..50d415c212a 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -184,6 +184,10 @@ springboot3-starter-security = { module = "org.springframework.boot:spring-boot-
 springboot3-starter-jdbc = { module = "org.springframework.boot:spring-boot-starter-jdbc", version.ref = "springboot3" }
 springboot3-starter-actuator = { module = "org.springframework.boot:spring-boot-starter-actuator", version.ref = "springboot3" }
 springboot3-starter-cache = { module = "org.springframework.boot:spring-boot-starter-cache", version.ref = "springboot3" }
+spring-kafka2 = { module = "org.springframework.kafka:spring-kafka", version = "2.8.11" }
+spring-kafka3 = { module = "org.springframework.kafka:spring-kafka", version = "3.3.5" }
+spring-kafka4 = { module = "org.springframework.kafka:spring-kafka" }
+kafka-clients = { module = "org.apache.kafka:kafka-clients", version = "3.8.1" }
 springboot4-otel = { module = "io.opentelemetry.instrumentation:opentelemetry-spring-boot-starter", version.ref = "otelInstrumentation" }
 springboot4-resttestclient = { module = "org.springframework.boot:spring-boot-resttestclient", version.ref = "springboot4" }
 springboot4-starter = { module = "org.springframework.boot:spring-boot-starter", version.ref = "springboot4" }
@@ -200,6 +204,7 @@ springboot4-starter-webclient = { module = "org.springframework.boot:spring-boot
 springboot4-starter-jdbc = { module = "org.springframework.boot:spring-boot-starter-jdbc", version.ref = "springboot4" }
 springboot4-starter-actuator = { module = "org.springframework.boot:spring-boot-starter-actuator", version.ref = "springboot4" }
 springboot4-starter-cache = { module = "org.springframework.boot:spring-boot-starter-cache", version.ref = "springboot4" }
+springboot4-starter-kafka = { module = "org.springframework.boot:spring-boot-starter-kafka", version.ref = "springboot4" }
 timber = { module = "com.jakewharton.timber:timber", version = "4.7.1" }
 
 # Animalsniffer signature
diff --git a/sentry-kafka/README.md b/sentry-kafka/README.md
new file mode 100644
index 00000000000..1b1b69238e5
--- /dev/null
+++ b/sentry-kafka/README.md
@@ -0,0 +1,5 @@
+# sentry-kafka
+
+This module provides Kafka-native queue instrumentation for applications using `kafka-clients` directly.
+
+Spring users should use the Sentry Spring (Boot) SDKs, which provide higher-fidelity consumer instrumentation via Spring Kafka hooks.
diff --git a/sentry-kafka/api/sentry-kafka.api b/sentry-kafka/api/sentry-kafka.api
new file mode 100644
index 00000000000..00649245845
--- /dev/null
+++ b/sentry-kafka/api/sentry-kafka.api
@@ -0,0 +1,19 @@
+public final class io/sentry/kafka/BuildConfig {
+	public static final field SENTRY_KAFKA_SDK_NAME Ljava/lang/String;
+	public static final field VERSION_NAME Ljava/lang/String;
+}
+
+public final class io/sentry/kafka/SentryKafkaConsumerTracing {
+	public static final field TRACE_ORIGIN Ljava/lang/String;
+	public static fun withTracing (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Ljava/lang/Runnable;)V
+	public static fun withTracing (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Ljava/util/concurrent/Callable;)Ljava/lang/Object;
+}
+
+public final class io/sentry/kafka/SentryKafkaProducer {
+	public static final field SENTRY_ENQUEUED_TIME_HEADER Ljava/lang/String;
+	public static final field TRACE_ORIGIN Ljava/lang/String;
+	public static fun wrap (Lorg/apache/kafka/clients/producer/Producer;)Lorg/apache/kafka/clients/producer/Producer;
+	public static fun wrap (Lorg/apache/kafka/clients/producer/Producer;Lio/sentry/IScopes;)Lorg/apache/kafka/clients/producer/Producer;
+	public static fun wrap (Lorg/apache/kafka/clients/producer/Producer;Lio/sentry/IScopes;Ljava/lang/String;)Lorg/apache/kafka/clients/producer/Producer;
+}
+
diff --git a/sentry-kafka/build.gradle.kts b/sentry-kafka/build.gradle.kts
new file mode 100644
index 00000000000..ee3ba0d4a60
--- /dev/null
+++ b/sentry-kafka/build.gradle.kts
@@ -0,0 +1,83 @@
+import net.ltgt.gradle.errorprone.errorprone
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+  `java-library`
+  id("io.sentry.javadoc")
+  alias(libs.plugins.kotlin.jvm)
+  jacoco
+  alias(libs.plugins.errorprone)
+  alias(libs.plugins.gradle.versions)
+  alias(libs.plugins.buildconfig)
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
+}
+
+dependencies {
+  api(projects.sentry)
+  compileOnly(libs.kafka.clients)
+  compileOnly(libs.jetbrains.annotations)
+  compileOnly(libs.nopen.annotations)
+
+  errorprone(libs.errorprone.core)
+  errorprone(libs.nopen.checker)
+  errorprone(libs.nullaway)
+
+  // tests
+  testImplementation(projects.sentryTestSupport)
+  testImplementation(kotlin(Config.kotlinStdLib))
+  testImplementation(libs.kotlin.test.junit)
+  testImplementation(libs.mockito.kotlin)
+  testImplementation(libs.mockito.inline)
+  testImplementation(libs.kafka.clients)
+}
+
+configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
+
+jacoco { toolVersion = libs.versions.jacoco.get() }
+
+tasks.jacocoTestReport {
+  reports {
+    xml.required.set(true)
+    html.required.set(false)
+  }
+}
+
+tasks {
+  jacocoTestCoverageVerification {
+    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
+  }
+  check {
+    dependsOn(jacocoTestCoverageVerification)
+    dependsOn(jacocoTestReport)
+  }
+}
+
+tasks.withType<JavaCompile>().configureEach {
+  options.errorprone {
+    check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
+    option("NullAway:AnnotatedPackages", "io.sentry")
+  }
+}
+
+buildConfig {
+  useJavaOutput()
+  packageName("io.sentry.kafka")
+  buildConfigField("String", "SENTRY_KAFKA_SDK_NAME", "\"${Config.Sentry.SENTRY_KAFKA_SDK_NAME}\"")
+  buildConfigField("String", "VERSION_NAME", "\"${project.version}\"")
+}
+
+tasks.jar {
+  manifest {
+    attributes(
+      "Sentry-Version-Name" to project.version,
+      "Sentry-SDK-Name" to Config.Sentry.SENTRY_KAFKA_SDK_NAME,
+      "Sentry-SDK-Package-Name" to "maven:io.sentry:sentry-kafka",
+      "Implementation-Vendor" to "Sentry",
+      "Implementation-Title" to project.name,
+      "Implementation-Version" to project.version,
+    )
+  }
+}
diff --git a/sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaConsumerTracing.java b/sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaConsumerTracing.java
new file mode 100644
index 00000000000..dbce760de99
--- /dev/null
+++ b/sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaConsumerTracing.java
@@ -0,0 +1,280 @@
+package io.sentry.kafka;
+
+import io.sentry.BaggageHeader;
+import io.sentry.DateUtils;
+import io.sentry.IScopes;
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.ITransaction;
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryLevel;
+import io.sentry.SentryTraceHeader;
+import io.sentry.SpanDataConvention;
+import io.sentry.SpanStatus;
+import io.sentry.TransactionContext;
+import io.sentry.TransactionOptions;
+import io.sentry.util.SpanUtils;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.common.header.Header;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/** Helper methods for instrumenting raw Kafka consumer record processing. */
+@ApiStatus.Experimental
+public final class SentryKafkaConsumerTracing {
+
+  public static final @NotNull String TRACE_ORIGIN = "manual.queue.kafka.consumer";
+
+  private static final @NotNull String CREATOR = "SentryKafkaConsumerTracing";
+  private static final @NotNull String DELIVERY_ATTEMPT_HEADER = "kafka_deliveryAttempt";
+  private static final @NotNull String MESSAGE_ID_HEADER = "messaging.message.id";
+
+  private final @NotNull IScopes scopes;
+
+  SentryKafkaConsumerTracing(final @NotNull IScopes scopes) {
+    this.scopes = scopes;
+  }
+
+  /**
+   * Runs the provided {@link Callable} with a Kafka consumer processing transaction for the given
+   * record.
+   *
+   * @param record the Kafka record being processed
+   * @param callable the processing callback
+   * @return the return value of the callback
+   * @param <K> the Kafka record key type
+   * @param <V> the Kafka record value type
+   * @param <U> the callback return type
+   */
+  public static <K, V, U> U withTracing(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Callable<U> callable)
+      throws Exception {
+    return new SentryKafkaConsumerTracing(ScopesAdapter.getInstance())
+        .withTracingImpl(record, callable);
+  }
+
+  /**
+   * Runs the provided {@link Runnable} with a Kafka consumer processing transaction for the given
+   * record.
+   *
+   * @param record the Kafka record being processed
+   * @param runnable the processing callback
+   * @param <K> the Kafka record key type
+   * @param <V> the Kafka record value type
+   */
+  public static <K, V> void withTracing(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Runnable runnable) {
+    new SentryKafkaConsumerTracing(ScopesAdapter.getInstance()).withTracingImpl(record, runnable);
+  }
+
+  <K, V, U> U withTracingImpl(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Callable<U> callable)
+      throws Exception {
+    if (!scopes.getOptions().isEnableQueueTracing() || isIgnored()) {
+      return callable.call();
+    }
+
+    final @NotNull IScopes forkedScopes;
+    final @NotNull ISentryLifecycleToken lifecycleToken;
+    try {
+      forkedScopes = scopes.forkedRootScopes(CREATOR);
+      lifecycleToken = forkedScopes.makeCurrent();
+    } catch (Throwable t) {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(SentryLevel.ERROR, "Failed to fork scopes for Kafka consumer tracing.", t);
+      return callable.call();
+    }
+
+    try (final @NotNull ISentryLifecycleToken ignored = lifecycleToken) {
+      final @Nullable ITransaction transaction = startTransaction(forkedScopes, record);
+      boolean didError = false;
+      @Nullable Throwable callbackThrowable = null;
+
+      try {
+        return callable.call();
+      } catch (Throwable t) {
+        didError = true;
+        callbackThrowable = t;
+        throw t;
+      } finally {
+        finishTransaction(
+            transaction, didError ? SpanStatus.INTERNAL_ERROR : SpanStatus.OK, callbackThrowable);
+      }
+    }
+  }
+
+  <K, V> void withTracingImpl(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Runnable runnable) {
+    try {
+      withTracingImpl(
+          record,
+          () -> {
+            runnable.run();
+            return null;
+          });
+    } catch (Throwable t) {
+      throwUnchecked(t);
+    }
+  }
+
+  @SuppressWarnings("unchecked")
+  private static <T extends Throwable> void throwUnchecked(final @NotNull Throwable throwable)
+      throws T {
+    throw (T) throwable;
+  }
+
+  private boolean isIgnored() {
+    return SpanUtils.isIgnored(scopes.getOptions().getIgnoredSpanOrigins(), TRACE_ORIGIN);
+  }
+
+  private <K, V> @Nullable ITransaction startTransaction(
+      final @NotNull IScopes forkedScopes, final @NotNull ConsumerRecord<K, V> record) {
+    try {
+      final @Nullable TransactionContext continued = continueTrace(forkedScopes, record);
+      if (!forkedScopes.getOptions().isTracingEnabled()) {
+        return null;
+      }
+
+      final @NotNull TransactionContext txContext =
+          continued != null ? continued : new TransactionContext(record.topic(), "queue.process");
+      txContext.setName(record.topic());
+      txContext.setOperation("queue.process");
+
+      final @NotNull TransactionOptions txOptions = new TransactionOptions();
+      txOptions.setOrigin(TRACE_ORIGIN);
+      txOptions.setBindToScope(true);
+
+      final @NotNull ITransaction transaction = forkedScopes.startTransaction(txContext, txOptions);
+      if (transaction.isNoOp()) {
+        return null;
+      }
+
+      transaction.setData(SpanDataConvention.MESSAGING_SYSTEM, "kafka");
+      transaction.setData(SpanDataConvention.MESSAGING_DESTINATION_NAME, record.topic());
+
+      final @Nullable String messageId = headerValue(record, MESSAGE_ID_HEADER);
+      if (messageId != null) {
+        transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_ID, messageId);
+      }
+
+      final int bodySize = record.serializedValueSize();
+      if (bodySize >= 0) {
+        transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE, bodySize);
+      }
+
+      final @Nullable Integer retryCount = retryCount(record);
+      if (retryCount != null) {
+        transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT, retryCount);
+      }
+
+      final @Nullable Long receiveLatency = receiveLatency(record);
+      if (receiveLatency != null) {
+        transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_RECEIVE_LATENCY, receiveLatency);
+      }
+
+      return transaction;
+    } catch (Throwable t) {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(SentryLevel.ERROR, "Failed to start Kafka consumer tracing transaction.", t);
+      return null;
+    }
+  }
+
+  private void finishTransaction(
+      final @Nullable ITransaction transaction,
+      final @NotNull SpanStatus status,
+      final @Nullable Throwable throwable) {
+    if (transaction == null || transaction.isNoOp()) {
+      return;
+    }
+
+    try {
+      transaction.setStatus(status);
+      if (throwable != null) {
+        transaction.setThrowable(throwable);
+      }
+      transaction.finish();
+    } catch (Throwable t) {
+      scopes
+          .getOptions()
+          .getLogger()
+          .log(SentryLevel.ERROR, "Failed to finish Kafka consumer tracing transaction.", t);
+    }
+  }
+
+  private <K, V> @Nullable TransactionContext continueTrace(
+      final @NotNull IScopes forkedScopes, final @NotNull ConsumerRecord<K, V> record) {
+    final @Nullable String sentryTrace = headerValue(record, SentryTraceHeader.SENTRY_TRACE_HEADER);
+    final @Nullable List<String> baggageHeaders =
+        headerValues(record, BaggageHeader.BAGGAGE_HEADER);
+    return forkedScopes.continueTrace(sentryTrace, baggageHeaders);
+  }
+
+  private <K, V> @Nullable Integer retryCount(final @NotNull ConsumerRecord<K, V> record) {
+    final @Nullable Header header = record.headers().lastHeader(DELIVERY_ATTEMPT_HEADER);
+    if (header == null) {
+      return null;
+    }
+
+    final byte[] value = header.value();
+    if (value == null || value.length != Integer.BYTES) {
+      return null;
+    }
+
+    final int attempt = ByteBuffer.wrap(value).getInt();
+    if (attempt <= 0) {
+      return null;
+    }
+
+    return attempt - 1;
+  }
+
+  private <K, V> @Nullable Long receiveLatency(final @NotNull ConsumerRecord<K, V> record) {
+    final @Nullable String enqueuedTimeStr =
+        headerValue(record, SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER);
+    if (enqueuedTimeStr == null) {
+      return null;
+    }
+
+    try {
+      final double enqueuedTimeSeconds = Double.parseDouble(enqueuedTimeStr);
+      final double nowSeconds = DateUtils.millisToSeconds(System.currentTimeMillis());
+      final long latencyMs = (long) ((nowSeconds - enqueuedTimeSeconds) * 1000);
+      return latencyMs >= 0 ? latencyMs : null;
+    } catch (NumberFormatException ignored) {
+      return null;
+    }
+  }
+
+  private <K, V> @Nullable String headerValue(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull String headerName) {
+    final @Nullable Header header = record.headers().lastHeader(headerName);
+    if (header == null || header.value() == null) {
+      return null;
+    }
+    return new String(header.value(), StandardCharsets.UTF_8);
+  }
+
+  private <K, V> @Nullable List<String> headerValues(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull String headerName) {
+    @Nullable List<String> values = null;
+    for (final @NotNull Header header : record.headers().headers(headerName)) {
+      if (header.value() != null) {
+        if (values == null) {
+          values = new ArrayList<>();
+        }
+        values.add(new String(header.value(), StandardCharsets.UTF_8));
+      }
+    }
+    return values;
+  }
+}
diff --git a/sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaProducer.java b/sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaProducer.java
new file mode 100644
index 00000000000..bcc538e339c
--- /dev/null
+++ b/sentry-kafka/src/main/java/io/sentry/kafka/SentryKafkaProducer.java
@@ -0,0 +1,265 @@
+package io.sentry.kafka;
+
+import io.sentry.BaggageHeader;
+import io.sentry.DateUtils;
+import io.sentry.IScopes;
+import io.sentry.ISpan;
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryLevel;
+import io.sentry.SentryTraceHeader;
+import io.sentry.SpanDataConvention;
+import io.sentry.SpanOptions;
+import io.sentry.SpanStatus;
+import io.sentry.util.SpanUtils;
+import io.sentry.util.TracingUtils;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.kafka.clients.producer.Callback;
+import org.apache.kafka.clients.producer.Producer;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.common.header.Header;
+import org.apache.kafka.common.header.Headers;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Wraps a Kafka {@link Producer} to record a {@code queue.publish} span around each {@code send}
+ * and to inject Sentry trace propagation headers into the produced record.
+ *
+ * <p>For raw Kafka usage:
+ *
+ * <pre>{@code
+ * Producer<String, String> producer =
+ *     SentryKafkaProducer.wrap(new KafkaProducer<>(props));
+ * }</pre>
+ *
+ * <p>For Spring Kafka, the {@code SentryKafkaProducerBeanPostProcessor} installs this wrapper
+ * automatically.
+ */
+@ApiStatus.Experimental
+public final class SentryKafkaProducer {
+
+  public static final @NotNull String TRACE_ORIGIN = "auto.queue.kafka.producer";
+  public static final @NotNull String SENTRY_ENQUEUED_TIME_HEADER = "sentry-task-enqueued-time";
+
+  private SentryKafkaProducer() {}
+
+  /**
+   * Wraps the given producer with Sentry instrumentation.
+   *
+   * @param delegate the Kafka producer to wrap
+   * @return an instrumented producer that records {@code queue.publish} spans
+   * @param <K> the Kafka record key type
+   * @param <V> the Kafka record value type
+   */
+  public static <K, V> @NotNull Producer<K, V> wrap(final @NotNull Producer<K, V> delegate) {
+    return wrap(delegate, ScopesAdapter.getInstance(), TRACE_ORIGIN);
+  }
+
+  /**
+   * Wraps the given producer with Sentry instrumentation using the provided scopes.
+   *
+   * @param delegate the Kafka producer to wrap
+   * @param scopes the Sentry scopes to use for span creation and header injection
+   * @return an instrumented producer that records {@code queue.publish} spans
+   * @param <K> the Kafka record key type
+   * @param <V> the Kafka record value type
+   */
+  public static <K, V> @NotNull Producer<K, V> wrap(
+      final @NotNull Producer<K, V> delegate, final @NotNull IScopes scopes) {
+    return wrap(delegate, scopes, TRACE_ORIGIN);
+  }
+
+  /**
+   * Wraps the given producer with Sentry instrumentation.
+   *
+   * @param delegate the Kafka producer to wrap
+   * @param scopes the Sentry scopes to use for span creation and header injection
+   * @param traceOrigin the trace origin to set on created spans
+   * @return an instrumented producer that records {@code queue.publish} spans
+   * @param <K> the Kafka record key type
+   * @param <V> the Kafka record value type
+   */
+  @SuppressWarnings("unchecked")
+  public static <K, V> @NotNull Producer<K, V> wrap(
+      final @NotNull Producer<K, V> delegate,
+      final @NotNull IScopes scopes,
+      final @NotNull String traceOrigin) {
+    return (Producer<K, V>)
+        Proxy.newProxyInstance(
+            delegate.getClass().getClassLoader(),
+            new Class<?>[] {Producer.class},
+            new SentryProducerHandler<>(delegate, scopes, traceOrigin));
+  }
+
+  static final class SentryProducerHandler<K, V> implements InvocationHandler {
+
+    final @NotNull Producer<K, V> delegate;
+    private final @NotNull IScopes scopes;
+    private final @NotNull String traceOrigin;
+
+    SentryProducerHandler(
+        final @NotNull Producer<K, V> delegate,
+        final @NotNull IScopes scopes,
+        final @NotNull String traceOrigin) {
+      this.delegate = delegate;
+      this.scopes = scopes;
+      this.traceOrigin = traceOrigin;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public @Nullable Object invoke(
+        final @NotNull Object proxy, final @NotNull Method method, final @Nullable Object[] args)
+        throws Throwable {
+      if ("send".equals(method.getName()) && args != null) {
+        if (args.length == 1) {
+          return instrumentedSend((ProducerRecord<K, V>) args[0], null);
+        } else if (args.length == 2) {
+          return instrumentedSend((ProducerRecord<K, V>) args[0], (Callback) args[1]);
+        }
+      }
+
+      if ("equals".equals(method.getName())
+          && args != null
+          && args.length == 1
+          && proxy == args[0]) {
+        return true;
+      }
+
+      if ("toString".equals(method.getName()) && (args == null || args.length == 0)) {
+        return "SentryKafkaProducer[delegate=" + delegate + "]";
+      }
+
+      try {
+        return method.invoke(delegate, args);
+      } catch (InvocationTargetException e) {
+        throw e.getCause();
+      }
+    }
+
+    @SuppressWarnings("unchecked")
+    private @NotNull Object instrumentedSend(
+        final @NotNull ProducerRecord<K, V> record, final @Nullable Callback callback) {
+      if (!scopes.getOptions().isEnableQueueTracing() || isIgnored()) {
+        return delegate.send(record, callback);
+      }
+
+      final @Nullable ISpan activeSpan = scopes.getSpan();
+      if (activeSpan == null || activeSpan.isNoOp()) {
+        maybeInjectHeaders(record.headers(), null);
+        return delegate.send(record, callback);
+      }
+
+      final @NotNull SpanOptions spanOptions = new SpanOptions();
+      spanOptions.setOrigin(traceOrigin);
+      final @NotNull ISpan span =
+          activeSpan.startChild("queue.publish", record.topic(), spanOptions);
+
+      span.setData(SpanDataConvention.MESSAGING_SYSTEM, "kafka");
+      span.setData(SpanDataConvention.MESSAGING_DESTINATION_NAME, record.topic());
+      maybeInjectHeaders(record.headers(), span);
+
+      try {
+        return delegate.send(record, wrapCallback(callback, span));
+      } catch (Throwable t) {
+        finishWithError(span, t);
+        throw t;
+      }
+    }
+
+    private @NotNull Callback wrapCallback(
+        final @Nullable Callback userCallback, final @NotNull ISpan span) {
+      return (metadata, exception) -> {
+        try {
+          if (exception != null) {
+            span.setThrowable(exception);
+            span.setStatus(SpanStatus.INTERNAL_ERROR);
+          } else {
+            span.setStatus(SpanStatus.OK);
+          }
+        } catch (Throwable t) {
+          scopes
+              .getOptions()
+              .getLogger()
+              .log(SentryLevel.ERROR, "Failed to set status on Kafka producer span.", t);
+        } finally {
+          try {
+            span.finish();
+          } finally {
+            if (userCallback != null) {
+              userCallback.onCompletion(metadata, exception);
+            }
+          }
+        }
+      };
+    }
+
+    private void finishWithError(final @NotNull ISpan span, final @NotNull Throwable t) {
+      span.setThrowable(t);
+      span.setStatus(SpanStatus.INTERNAL_ERROR);
+      span.finish();
+    }
+
+    private boolean isIgnored() {
+      return SpanUtils.isIgnored(scopes.getOptions().getIgnoredSpanOrigins(), traceOrigin);
+    }
+
+    private void maybeInjectHeaders(final @NotNull Headers headers, final @Nullable ISpan span) {
+      try {
+        final @Nullable List<String> existingBaggageHeaders =
+            readHeaderValues(headers, BaggageHeader.BAGGAGE_HEADER);
+        final @Nullable TracingUtils.TracingHeaders tracingHeaders =
+            TracingUtils.trace(scopes, existingBaggageHeaders, span);
+        if (tracingHeaders != null) {
+          final @NotNull SentryTraceHeader sentryTraceHeader =
+              tracingHeaders.getSentryTraceHeader();
+          headers.remove(sentryTraceHeader.getName());
+          headers.add(
+              sentryTraceHeader.getName(),
+              sentryTraceHeader.getValue().getBytes(StandardCharsets.UTF_8));
+
+          final @Nullable BaggageHeader baggageHeader = tracingHeaders.getBaggageHeader();
+          if (baggageHeader != null) {
+            headers.remove(baggageHeader.getName());
+            headers.add(
+                baggageHeader.getName(), baggageHeader.getValue().getBytes(StandardCharsets.UTF_8));
+          }
+        }
+
+        headers.remove(SENTRY_ENQUEUED_TIME_HEADER);
+        headers.add(
+            SENTRY_ENQUEUED_TIME_HEADER,
+            DateUtils.doubleToBigDecimal(DateUtils.millisToSeconds(System.currentTimeMillis()))
+                .toString()
+                .getBytes(StandardCharsets.UTF_8));
+      } catch (Throwable t) {
+        scopes
+            .getOptions()
+            .getLogger()
+            .log(SentryLevel.ERROR, "Failed to inject Sentry headers into Kafka record.", t);
+      }
+    }
+
+    private static @Nullable List<String> readHeaderValues(
+        final @NotNull Headers headers, final @NotNull String name) {
+      @Nullable List<String> values = null;
+      for (final @NotNull Header header : headers.headers(name)) {
+        final byte @Nullable [] value = header.value();
+        if (value != null) {
+          if (values == null) {
+            values = new ArrayList<>();
+          }
+          values.add(new String(value, StandardCharsets.UTF_8));
+        }
+      }
+      return values;
+    }
+  }
+}
diff --git a/sentry-kafka/src/test/kotlin/io/sentry/kafka/SentryKafkaConsumerTracingTest.kt b/sentry-kafka/src/test/kotlin/io/sentry/kafka/SentryKafkaConsumerTracingTest.kt
new file mode 100644
index 00000000000..5529e42c715
--- /dev/null
+++ b/sentry-kafka/src/test/kotlin/io/sentry/kafka/SentryKafkaConsumerTracingTest.kt
@@ -0,0 +1,254 @@
+package io.sentry.kafka
+
+import io.sentry.BaggageHeader
+import io.sentry.IScopes
+import io.sentry.ISentryLifecycleToken
+import io.sentry.ITransaction
+import io.sentry.SentryOptions
+import io.sentry.SentryTraceHeader
+import io.sentry.SpanDataConvention
+import io.sentry.SpanStatus
+import io.sentry.TransactionContext
+import io.sentry.TransactionOptions
+import java.io.IOException
+import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
+import java.util.Optional
+import java.util.concurrent.Callable
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertTrue
+import org.apache.kafka.clients.consumer.ConsumerRecord
+import org.apache.kafka.common.header.internals.RecordHeaders
+import org.apache.kafka.common.record.TimestampType
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.check
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class SentryKafkaConsumerTracingTest {
+
+  private lateinit var scopes: IScopes
+  private lateinit var forkedScopes: IScopes
+  private lateinit var options: SentryOptions
+  private lateinit var lifecycleToken: ISentryLifecycleToken
+  private lateinit var transaction: ITransaction
+  private lateinit var tracing: SentryKafkaConsumerTracing
+
+  @BeforeTest
+  fun setup() {
+    scopes = mock()
+    forkedScopes = mock()
+    lifecycleToken = mock()
+    transaction = mock()
+    tracing = SentryKafkaConsumerTracing(scopes)
+
+    options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        isEnableQueueTracing = true
+        tracesSampleRate = 1.0
+      }
+
+    whenever(scopes.options).thenReturn(options)
+    whenever(scopes.forkedRootScopes(any())).thenReturn(forkedScopes)
+    whenever(forkedScopes.options).thenReturn(options)
+    whenever(forkedScopes.makeCurrent()).thenReturn(lifecycleToken)
+    whenever(forkedScopes.startTransaction(any<TransactionContext>(), any<TransactionOptions>()))
+      .thenReturn(transaction)
+    whenever(transaction.isNoOp).thenReturn(false)
+  }
+
+  @Test
+  fun `withTracing creates queue process transaction with record metadata`() {
+    val sentryTraceValue = "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1"
+    val baggageValue = "sentry-sample_rate=1"
+    val record =
+      createRecord(
+        sentryTrace = sentryTraceValue,
+        baggage = baggageValue,
+        messageId = "message-123",
+        deliveryAttempt = 3,
+        enqueuedTime = (System.currentTimeMillis() / 1000.0 - 1.0).toString(),
+        serializedValueSize = 5,
+      )
+
+    val txContextCaptor = argumentCaptor<TransactionContext>()
+    val txOptionsCaptor = argumentCaptor<TransactionOptions>()
+
+    val result = tracing.withTracingImpl(record, Callable { "done" })
+
+    assertEquals("done", result)
+    verify(scopes).forkedRootScopes("SentryKafkaConsumerTracing")
+    verify(forkedScopes).makeCurrent()
+    verify(forkedScopes).continueTrace(eq(sentryTraceValue), eq(listOf(baggageValue)))
+    verify(forkedScopes).startTransaction(txContextCaptor.capture(), txOptionsCaptor.capture())
+
+    assertEquals("my-topic", txContextCaptor.firstValue.name)
+    assertEquals("queue.process", txContextCaptor.firstValue.operation)
+    assertEquals(SentryKafkaConsumerTracing.TRACE_ORIGIN, txOptionsCaptor.firstValue.origin)
+    assertTrue(txOptionsCaptor.firstValue.isBindToScope)
+
+    verify(transaction).setData(SpanDataConvention.MESSAGING_SYSTEM, "kafka")
+    verify(transaction).setData(SpanDataConvention.MESSAGING_DESTINATION_NAME, "my-topic")
+    verify(transaction).setData(SpanDataConvention.MESSAGING_MESSAGE_ID, "message-123")
+    verify(transaction).setData(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE, 5)
+    verify(transaction).setData(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT, 2)
+    verify(transaction)
+      .setData(
+        eq(SpanDataConvention.MESSAGING_MESSAGE_RECEIVE_LATENCY),
+        check<Long> { assertTrue(it >= 0) },
+      )
+    verify(transaction).setStatus(SpanStatus.OK)
+    verify(transaction).finish()
+    verify(lifecycleToken).close()
+  }
+
+  @Test
+  fun `withTracing passes all baggage headers to continueTrace`() {
+    val sentryTraceValue = "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1"
+    val record =
+      createRecord(
+        sentryTrace = sentryTraceValue,
+        baggageHeaders = listOf("third=party", "sentry-sample_rate=1"),
+      )
+
+    tracing.withTracingImpl(record, Callable { "done" })
+
+    verify(forkedScopes)
+      .continueTrace(eq(sentryTraceValue), eq(listOf("third=party", "sentry-sample_rate=1")))
+  }
+
+  @Test
+  fun `withTracing skips scope forking when queue tracing is disabled`() {
+    options.isEnableQueueTracing = false
+    val record = createRecord()
+
+    val result = tracing.withTracingImpl(record, Callable { "done" })
+
+    assertEquals("done", result)
+    verify(scopes, never()).forkedRootScopes(any<String>())
+  }
+
+  @Test
+  fun `withTracing skips scope forking when origin is ignored`() {
+    options.setIgnoredSpanOrigins(listOf(SentryKafkaConsumerTracing.TRACE_ORIGIN))
+    val record = createRecord()
+
+    val result = tracing.withTracingImpl(record, Callable { "done" })
+
+    assertEquals("done", result)
+    verify(scopes, never()).forkedRootScopes(any<String>())
+  }
+
+  @Test
+  fun `withTracing marks transaction as error when callback throws`() {
+    val record = createRecord()
+    val exception = RuntimeException("boom")
+
+    val thrown =
+      assertFailsWith<RuntimeException> {
+        tracing.withTracingImpl(record, Callable<String> { throw exception })
+      }
+
+    assertEquals(exception, thrown)
+    verify(transaction).setStatus(SpanStatus.INTERNAL_ERROR)
+    verify(transaction).setThrowable(exception)
+    verify(transaction).finish()
+    verify(lifecycleToken).close()
+  }
+
+  @Test
+  fun `withTracing falls back to direct callback execution when instrumentation setup fails`() {
+    whenever(scopes.forkedRootScopes(any<String>()))
+      .thenThrow(RuntimeException("broken instrumentation"))
+    val record = createRecord()
+
+    val result = tracing.withTracingImpl(record, Callable { "done" })
+
+    assertEquals("done", result)
+    verify(forkedScopes, never()).makeCurrent()
+    verify(transaction, never()).finish()
+  }
+
+  @Test
+  fun `withTracing runnable overload executes callback`() {
+    val record = createRecord()
+    val didRun = AtomicBoolean(false)
+
+    tracing.withTracingImpl(record, Runnable { didRun.set(true) })
+
+    assertTrue(didRun.get())
+    verify(transaction).setStatus(SpanStatus.OK)
+    verify(transaction).finish()
+  }
+
+  @Test
+  fun `withTracing runnable overload preserves original throwable`() {
+    val record = createRecord()
+    val exception = IOException("boom")
+
+    val thrown =
+      assertFailsWith<IOException> { tracing.withTracingImpl(record, Runnable { throw exception }) }
+
+    assertEquals(exception, thrown)
+    verify(transaction).setStatus(SpanStatus.INTERNAL_ERROR)
+    verify(transaction).setThrowable(exception)
+    verify(transaction).finish()
+  }
+
+  private fun createRecord(
+    topic: String = "my-topic",
+    sentryTrace: String? = null,
+    baggage: String? = null,
+    baggageHeaders: List<String>? = null,
+    messageId: String? = null,
+    deliveryAttempt: Int? = null,
+    enqueuedTime: String? = null,
+    serializedValueSize: Int = -1,
+  ): ConsumerRecord<String, String> {
+    val headers = RecordHeaders()
+    sentryTrace?.let {
+      headers.add(SentryTraceHeader.SENTRY_TRACE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    baggage?.let {
+      headers.add(BaggageHeader.BAGGAGE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    baggageHeaders?.forEach {
+      headers.add(BaggageHeader.BAGGAGE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    messageId?.let {
+      headers.add(SpanDataConvention.MESSAGING_MESSAGE_ID, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    deliveryAttempt?.let {
+      headers.add("kafka_deliveryAttempt", ByteBuffer.allocate(Int.SIZE_BYTES).putInt(it).array())
+    }
+    enqueuedTime?.let {
+      headers.add(
+        SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER,
+        it.toByteArray(StandardCharsets.UTF_8),
+      )
+    }
+
+    return ConsumerRecord(
+      topic,
+      0,
+      0L,
+      System.currentTimeMillis(),
+      TimestampType.CREATE_TIME,
+      3,
+      serializedValueSize,
+      "key",
+      "value",
+      headers,
+      Optional.empty(),
+    )
+  }
+}
diff --git a/sentry-kafka/src/test/kotlin/io/sentry/kafka/SentryKafkaProducerTest.kt b/sentry-kafka/src/test/kotlin/io/sentry/kafka/SentryKafkaProducerTest.kt
new file mode 100644
index 00000000000..a4ba5254c36
--- /dev/null
+++ b/sentry-kafka/src/test/kotlin/io/sentry/kafka/SentryKafkaProducerTest.kt
@@ -0,0 +1,375 @@
+package io.sentry.kafka
+
+import io.sentry.BaggageHeader
+import io.sentry.IScopes
+import io.sentry.ISentryLifecycleToken
+import io.sentry.ISpan
+import io.sentry.NoOpSpan
+import io.sentry.Scope
+import io.sentry.ScopeCallback
+import io.sentry.Sentry
+import io.sentry.SentryOptions
+import io.sentry.SentryTraceHeader
+import io.sentry.SentryTracer
+import io.sentry.SpanOptions
+import io.sentry.SpanStatus
+import io.sentry.TransactionContext
+import io.sentry.test.initForTest
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.CompletableFuture
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.apache.kafka.clients.producer.Callback
+import org.apache.kafka.clients.producer.Producer
+import org.apache.kafka.clients.producer.ProducerRecord
+import org.apache.kafka.clients.producer.RecordMetadata
+import org.apache.kafka.common.TopicPartition
+import org.apache.kafka.common.header.Header
+import org.apache.kafka.common.header.Headers
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.isNull
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class SentryKafkaProducerTest {
+
+  private lateinit var scopes: IScopes
+  private lateinit var options: SentryOptions
+  private lateinit var delegate: Producer<String, String>
+
+  @BeforeTest
+  fun setup() {
+    initForTest {
+      it.dsn = "https://key@sentry.io/proj"
+      it.isEnableQueueTracing = true
+      it.tracesSampleRate = 1.0
+    }
+    scopes = mock()
+    options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        isEnableQueueTracing = true
+      }
+    whenever(scopes.options).thenReturn(options)
+    doAnswer { (it.arguments[0] as ScopeCallback).run(Scope(options)) }
+      .whenever(scopes)
+      .configureScope(any())
+    delegate = mock()
+    whenever(delegate.send(any(), any())).thenReturn(CompletableFuture.completedFuture(null))
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+  }
+
+  @Test
+  fun `creates queue publish span and injects headers`() {
+    val tx = createTransaction()
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    producer.send(record)
+
+    assertEquals(1, tx.spans.size)
+    val span = tx.spans.first()
+    assertEquals("queue.publish", span.operation)
+    assertEquals("my-topic", span.description)
+    assertEquals("kafka", span.data["messaging.system"])
+    assertEquals("my-topic", span.data["messaging.destination.name"])
+    assertEquals(SentryKafkaProducer.TRACE_ORIGIN, span.spanContext.origin)
+
+    val sentryTraceHeader = record.headers().lastHeader(SentryTraceHeader.SENTRY_TRACE_HEADER)
+    assertNotNull(sentryTraceHeader)
+
+    val enqueuedTimeHeader =
+      record.headers().lastHeader(SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER)
+    assertNotNull(enqueuedTimeHeader)
+    val enqueuedTimeRaw = String(enqueuedTimeHeader.value(), StandardCharsets.UTF_8)
+    // Cross-SDK consumers (e.g. sentry-python) parse this as a plain decimal — must not use
+    // scientific notation.
+    assertFalse(enqueuedTimeRaw.contains('E') || enqueuedTimeRaw.contains('e'))
+    assertTrue(enqueuedTimeRaw.matches(Regex("""^\d+\.\d{6}$""")))
+  }
+
+  @Test
+  fun `delegates send and does not finish span synchronously`() {
+    val tx = createTransaction()
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    producer.send(record)
+
+    verify(delegate).send(eq(record), any<Callback>())
+    val span = tx.spans.first()
+    assertFalse(span.isFinished, "span should be open until callback fires")
+  }
+
+  @Test
+  fun `finishes span as OK when broker ack callback succeeds`() {
+    val tx = createTransaction()
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    producer.send(record)
+
+    val captor = argumentCaptor<Callback>()
+    verify(delegate).send(eq(record), captor.capture())
+    val metadata = RecordMetadata(TopicPartition("my-topic", 0), 0L, 0, 0L, 0, 0)
+    captor.firstValue.onCompletion(metadata, null)
+
+    val span = tx.spans.first()
+    assertTrue(span.isFinished)
+    assertEquals(SpanStatus.OK, span.status)
+  }
+
+  @Test
+  fun `finishes span as INTERNAL_ERROR when broker ack callback fails`() {
+    val tx = createTransaction()
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+    val exception = RuntimeException("boom")
+
+    producer.send(record)
+
+    val captor = argumentCaptor<Callback>()
+    verify(delegate).send(eq(record), captor.capture())
+    captor.firstValue.onCompletion(null, exception)
+
+    val span = tx.spans.first()
+    assertTrue(span.isFinished)
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertSame(exception, span.throwable)
+  }
+
+  @Test
+  fun `forwards user callback after finishing span`() {
+    createTransaction()
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+    val userCallback = mock<Callback>()
+
+    producer.send(record, userCallback)
+
+    val captor = argumentCaptor<Callback>()
+    verify(delegate).send(eq(record), captor.capture())
+    val metadata = RecordMetadata(TopicPartition("my-topic", 0), 0L, 0, 0L, 0, 0)
+    captor.firstValue.onCompletion(metadata, null)
+
+    verify(userCallback).onCompletion(metadata, null)
+  }
+
+  @Test
+  fun `finishes span with error when delegate send throws synchronously`() {
+    val tx = createTransaction()
+    val exception = RuntimeException("kaboom")
+    whenever(delegate.send(any(), any())).thenThrow(exception)
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    val thrown = runCatching { producer.send(record) }.exceptionOrNull()
+
+    assertSame(exception, thrown)
+    val span = tx.spans.first()
+    assertTrue(span.isFinished)
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertSame(exception, span.throwable)
+  }
+
+  @Test
+  fun `delegates send without span when queue tracing is disabled`() {
+    createTransaction()
+    options.isEnableQueueTracing = false
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    producer.send(record)
+
+    verify(delegate).send(eq(record), isNull())
+  }
+
+  @Test
+  fun `delegates send without span when trace origin is ignored`() {
+    val tx = createTransaction()
+    options.setIgnoredSpanOrigins(listOf(SentryKafkaProducer.TRACE_ORIGIN))
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    producer.send(record)
+
+    assertEquals(0, tx.spans.size)
+    verify(delegate).send(eq(record), isNull())
+    assertEquals(null, record.headers().lastHeader(SentryTraceHeader.SENTRY_TRACE_HEADER))
+  }
+
+  @Test
+  fun `injects headers but creates no span when no active span`() {
+    whenever(scopes.span).thenReturn(null)
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    producer.send(record)
+
+    verify(delegate).send(eq(record), isNull())
+    // Headers should still be injected from PropagationContext
+    assertNotNull(record.headers().lastHeader(SentryTraceHeader.SENTRY_TRACE_HEADER))
+    assertNotNull(record.headers().lastHeader(BaggageHeader.BAGGAGE_HEADER))
+    assertNotNull(record.headers().lastHeader(SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER))
+  }
+
+  @Test
+  fun `injects headers but creates no span when active span is no-op`() {
+    whenever(scopes.span).thenReturn(NoOpSpan.getInstance())
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    producer.send(record)
+
+    verify(delegate).send(eq(record), isNull())
+    // Headers should still be injected from PropagationContext
+    assertNotNull(record.headers().lastHeader(SentryTraceHeader.SENTRY_TRACE_HEADER))
+    assertNotNull(record.headers().lastHeader(BaggageHeader.BAGGAGE_HEADER))
+    assertNotNull(record.headers().lastHeader(SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER))
+  }
+
+  @Test
+  fun `preserves pre-existing third-party baggage header entries`() {
+    createTransaction()
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+    record
+      .headers()
+      .add(
+        BaggageHeader.BAGGAGE_HEADER,
+        "othervendor=someValue,another=thing".toByteArray(StandardCharsets.UTF_8),
+      )
+
+    producer.send(record)
+
+    val baggageHeaders = record.headers().headers(BaggageHeader.BAGGAGE_HEADER).toList()
+    assertEquals(1, baggageHeaders.size)
+    val baggageValue = String(baggageHeaders.first().value(), StandardCharsets.UTF_8)
+    assertTrue(baggageValue.contains("othervendor=someValue"))
+    assertTrue(baggageValue.contains("another=thing"))
+    assertTrue(baggageValue.contains("sentry-"))
+  }
+
+  @Test
+  fun `header injection failure does not prevent send`() {
+    val activeSpan = mock<ISpan>()
+    val span = mock<ISpan>()
+    val headers = mock<Headers>()
+    val record = mock<ProducerRecord<String, String>>()
+    whenever(scopes.span).thenReturn(activeSpan)
+    whenever(activeSpan.startChild(eq("queue.publish"), eq("my-topic"), any<SpanOptions>()))
+      .thenReturn(span)
+    whenever(span.isNoOp).thenReturn(false)
+    whenever(span.isFinished).thenReturn(false)
+    whenever(span.toSentryTrace())
+      .thenReturn(SentryTraceHeader("2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1"))
+    whenever(span.toBaggageHeader(null)).thenReturn(null)
+    whenever(record.topic()).thenReturn("my-topic")
+    whenever(record.headers()).thenReturn(headers)
+    whenever(headers.headers(BaggageHeader.BAGGAGE_HEADER)).thenReturn(emptyList<Header>())
+    whenever(headers.remove(SentryTraceHeader.SENTRY_TRACE_HEADER))
+      .thenThrow(RuntimeException("boom"))
+
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    producer.send(record)
+
+    // Header injection failed silently; send still proceeds with wrapped callback for span
+    // lifecycle.
+    verify(delegate).send(eq(record), any<Callback>())
+  }
+
+  @Test
+  fun `delegates non-send methods to underlying producer`() {
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+
+    producer.flush()
+    producer.partitionsFor("my-topic")
+    producer.metrics()
+    producer.close()
+
+    verify(delegate).flush()
+    verify(delegate).partitionsFor("my-topic")
+    verify(delegate).metrics()
+    verify(delegate).close()
+  }
+
+  @Test
+  fun `default wrap uses current scopes`() {
+    val transaction = Sentry.startTransaction("tx", "op")
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    try {
+      val token: ISentryLifecycleToken = transaction.makeCurrent()
+      try {
+        val producer = SentryKafkaProducer.wrap(delegate)
+        producer.send(record)
+      } finally {
+        token.close()
+      }
+    } finally {
+      transaction.finish()
+    }
+
+    assertNotNull(record.headers().lastHeader(SentryTraceHeader.SENTRY_TRACE_HEADER))
+    assertNotNull(record.headers().lastHeader(SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER))
+    verify(delegate).send(eq(record), any<Callback>())
+  }
+
+  @Test
+  fun `wraps callback even when child span is no-op`() {
+    val tx = createTransaction()
+    // Set max spans to 0 so the child span is no-op (over limit)
+    options.maxSpans = 0
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    val record = ProducerRecord<String, String>("my-topic", "key", "value")
+
+    producer.send(record)
+
+    // Callback is still wrapped (no-op span finish is harmless)
+    verify(delegate).send(eq(record), any<Callback>())
+    // Headers should still be injected from PropagationContext
+    assertNotNull(record.headers().lastHeader(SentryTraceHeader.SENTRY_TRACE_HEADER))
+    assertNotNull(record.headers().lastHeader(BaggageHeader.BAGGAGE_HEADER))
+    assertNotNull(record.headers().lastHeader(SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER))
+  }
+
+  @Test
+  fun `wrapped producer equals itself`() {
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+
+    assertTrue(producer.equals(producer))
+  }
+
+  @Test
+  fun `wrapped producer keeps delegate hashCode`() {
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+
+    assertEquals(delegate.hashCode(), producer.hashCode())
+  }
+
+  @Test
+  fun `toString includes delegate`() {
+    val producer = SentryKafkaProducer.wrap(delegate, scopes)
+    assertTrue(producer.toString().startsWith("SentryKafkaProducer[delegate="))
+  }
+
+  private fun createTransaction(): SentryTracer {
+    val tx = SentryTracer(TransactionContext("tx", "op"), scopes)
+    whenever(scopes.span).thenReturn(tx)
+    return tx
+  }
+}
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/api/sentry-opentelemetry-core.api b/sentry-opentelemetry/sentry-opentelemetry-core/api/sentry-opentelemetry-core.api
index b51c8cc39bc..847d69bca1b 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/api/sentry-opentelemetry-core.api
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/api/sentry-opentelemetry-core.api
@@ -149,7 +149,7 @@ public final class io/sentry/opentelemetry/SentrySpanProcessor : io/opentelemetr
 
 public final class io/sentry/opentelemetry/SpanDescriptionExtractor {
 	public fun <init> ()V
-	public fun extractSpanInfo (Lio/opentelemetry/sdk/trace/data/SpanData;Lio/sentry/opentelemetry/IOtelSpanWrapper;)Lio/sentry/opentelemetry/OtelSpanInfo;
+	public fun extractSpanInfo (Lio/opentelemetry/sdk/trace/data/SpanData;Lio/sentry/opentelemetry/IOtelSpanWrapper;Lio/sentry/SentryOptions;)Lio/sentry/opentelemetry/OtelSpanInfo;
 }
 
 public final class io/sentry/opentelemetry/SpanNode {
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java
index 680177f8451..2583f4a0469 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanExporter.java
@@ -12,6 +12,7 @@
 import io.opentelemetry.sdk.trace.data.StatusData;
 import io.opentelemetry.sdk.trace.export.SpanExporter;
 import io.opentelemetry.semconv.HttpAttributes;
+import io.opentelemetry.semconv.incubating.MessagingIncubatingAttributes;
 import io.opentelemetry.semconv.incubating.ProcessIncubatingAttributes;
 import io.opentelemetry.semconv.incubating.ThreadIncubatingAttributes;
 import io.sentry.Baggage;
@@ -200,7 +201,7 @@ private void createAndFinishSpanForOtelSpan(
     final @Nullable IOtelSpanWrapper sentrySpanMaybe =
         spanStorage.getSentrySpan(spanData.getSpanContext());
     final @NotNull OtelSpanInfo spanInfo =
-        spanDescriptionExtractor.extractSpanInfo(spanData, sentrySpanMaybe);
+        spanDescriptionExtractor.extractSpanInfo(spanData, sentrySpanMaybe, scopes.getOptions());
 
     scopes
         .getOptions()
@@ -294,7 +295,7 @@ private void transferSpanDetails(
     final @NotNull IScopes scopesToUse =
         scopesToUseBeforeForking.forkedCurrentScope("SentrySpanExporter.createTransaction");
     final @NotNull OtelSpanInfo spanInfo =
-        spanDescriptionExtractor.extractSpanInfo(span, sentrySpanMaybe);
+        spanDescriptionExtractor.extractSpanInfo(span, sentrySpanMaybe, scopesToUse.getOptions());
 
     scopesToUse
         .getOptions()
@@ -361,6 +362,19 @@ private void transferSpanDetails(
     maybeTransferOtelAttribute(span, sentryTransaction, ThreadIncubatingAttributes.THREAD_ID);
     maybeTransferOtelAttribute(span, sentryTransaction, ThreadIncubatingAttributes.THREAD_NAME);
 
+    maybeTransferOtelAttribute(
+        span, sentryTransaction, MessagingIncubatingAttributes.MESSAGING_SYSTEM);
+    maybeTransferOtelAttribute(
+        span, sentryTransaction, MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME);
+    maybeTransferOtelAttribute(
+        span, sentryTransaction, MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE);
+    maybeTransferOtelAttribute(
+        span, sentryTransaction, MessagingIncubatingAttributes.MESSAGING_MESSAGE_ID);
+    maybeTransferOtelAttribute(
+        span, sentryTransaction, MessagingIncubatingAttributes.MESSAGING_MESSAGE_BODY_SIZE);
+    maybeTransferOtelAttribute(
+        span, sentryTransaction, MessagingIncubatingAttributes.MESSAGING_MESSAGE_ENVELOPE_SIZE);
+
     scopesToUse.configureScope(
         ScopeType.CURRENT,
         scope -> attributesExtractor.extract(span, scope, scopesToUse.getOptions()));
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanProcessor.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanProcessor.java
index 9c6a51f17c3..31bd6368318 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanProcessor.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SentrySpanProcessor.java
@@ -297,7 +297,7 @@ private boolean isSentryRequest(final @NotNull ReadableSpan otelSpan) {
   private void updateTransactionWithOtelData(
       final @NotNull ITransaction sentryTransaction, final @NotNull ReadableSpan otelSpan) {
     final @NotNull OtelSpanInfo otelSpanInfo =
-        spanDescriptionExtractor.extractSpanInfo(otelSpan.toSpanData(), null);
+        spanDescriptionExtractor.extractSpanInfo(otelSpan.toSpanData(), null, scopes.getOptions());
     sentryTransaction.setOperation(otelSpanInfo.getOp());
     String transactionName = otelSpanInfo.getDescription();
     sentryTransaction.setName(
@@ -334,7 +334,7 @@ private void updateSpanWithOtelData(
             });
 
     final @NotNull OtelSpanInfo otelSpanInfo =
-        spanDescriptionExtractor.extractSpanInfo(otelSpan.toSpanData(), null);
+        spanDescriptionExtractor.extractSpanInfo(otelSpan.toSpanData(), null, scopes.getOptions());
     sentrySpan.setOperation(otelSpanInfo.getOp());
     sentrySpan.setDescription(otelSpanInfo.getDescription());
   }
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SpanDescriptionExtractor.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SpanDescriptionExtractor.java
index b66555d68c9..3af3d8f96f0 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SpanDescriptionExtractor.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/SpanDescriptionExtractor.java
@@ -7,6 +7,8 @@
 import io.opentelemetry.semconv.UrlAttributes;
 import io.opentelemetry.semconv.incubating.DbIncubatingAttributes;
 import io.opentelemetry.semconv.incubating.HttpIncubatingAttributes;
+import io.opentelemetry.semconv.incubating.MessagingIncubatingAttributes;
+import io.sentry.SentryOptions;
 import io.sentry.protocol.TransactionNameSource;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
@@ -17,9 +19,19 @@ public final class SpanDescriptionExtractor {
 
   @SuppressWarnings("deprecation")
   public @NotNull OtelSpanInfo extractSpanInfo(
-      final @NotNull SpanData otelSpan, final @Nullable IOtelSpanWrapper sentrySpan) {
+      final @NotNull SpanData otelSpan,
+      final @Nullable IOtelSpanWrapper sentrySpan,
+      final @NotNull SentryOptions options) {
     final @NotNull Attributes attributes = otelSpan.getAttributes();
 
+    if (options.isEnableQueueTracing()) {
+      final @Nullable String messagingSystem =
+          attributes.get(MessagingIncubatingAttributes.MESSAGING_SYSTEM);
+      if (messagingSystem != null) {
+        return descriptionForMessagingSystem(otelSpan);
+      }
+    }
+
     final @Nullable String httpMethod = attributes.get(HttpAttributes.HTTP_REQUEST_METHOD);
     if (httpMethod != null) {
       return descriptionForHttpMethod(otelSpan, httpMethod);
@@ -91,6 +103,53 @@ private static boolean isRootSpan(SpanData otelSpan) {
     return !otelSpan.getParentSpanContext().isValid() || otelSpan.getParentSpanContext().isRemote();
   }
 
+  @SuppressWarnings("deprecation")
+  private OtelSpanInfo descriptionForMessagingSystem(final @NotNull SpanData otelSpan) {
+    final @NotNull Attributes attributes = otelSpan.getAttributes();
+    final @NotNull String op = opForMessaging(otelSpan);
+    final @Nullable String destination =
+        attributes.get(MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME);
+    final @NotNull String description = destination != null ? destination : otelSpan.getName();
+    return new OtelSpanInfo(op, description, TransactionNameSource.TASK);
+  }
+
+  @SuppressWarnings("deprecation")
+  private @NotNull String opForMessaging(final @NotNull SpanData otelSpan) {
+    final @NotNull Attributes attributes = otelSpan.getAttributes();
+    @Nullable
+    String operationType = attributes.get(MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE);
+    if (operationType == null) {
+      operationType = attributes.get(MessagingIncubatingAttributes.MESSAGING_OPERATION);
+    }
+    if (operationType != null) {
+      switch (operationType) {
+        case "publish":
+        case "send":
+          return "queue.publish";
+        case "create":
+          return "queue.create";
+        case "receive":
+          return "queue.receive";
+        case "process":
+        case "deliver":
+          return "queue.process";
+        case "settle":
+          return "queue.settle";
+        default:
+          break;
+      }
+    }
+
+    final @NotNull SpanKind kind = otelSpan.getKind();
+    if (SpanKind.PRODUCER.equals(kind)) {
+      return "queue.publish";
+    }
+    if (SpanKind.CONSUMER.equals(kind)) {
+      return "queue.process";
+    }
+    return "queue";
+  }
+
   @SuppressWarnings("deprecation")
   private OtelSpanInfo descriptionForDbSystem(final @NotNull SpanData otelSpan) {
     final @NotNull Attributes attributes = otelSpan.getAttributes();
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SpanDescriptionExtractorTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SpanDescriptionExtractorTest.kt
index 9c5a1a352df..a43afb849e6 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SpanDescriptionExtractorTest.kt
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/SpanDescriptionExtractorTest.kt
@@ -11,6 +11,8 @@ import io.opentelemetry.semconv.HttpAttributes
 import io.opentelemetry.semconv.UrlAttributes
 import io.opentelemetry.semconv.incubating.DbIncubatingAttributes
 import io.opentelemetry.semconv.incubating.HttpIncubatingAttributes
+import io.opentelemetry.semconv.incubating.MessagingIncubatingAttributes
+import io.sentry.SentryOptions
 import io.sentry.protocol.TransactionNameSource
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -228,6 +230,250 @@ class SpanDescriptionExtractorTest {
     assertEquals(TransactionNameSource.TASK, info.transactionNameSource)
   }
 
+  @Test
+  fun `ignores messaging system when queue tracing disabled`() {
+    givenSpanName("my-topic publish")
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-topic",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "publish",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = false)
+
+    assertEquals("my-topic publish", info.op)
+    assertEquals("my-topic publish", info.description)
+    assertEquals(TransactionNameSource.CUSTOM, info.transactionNameSource)
+  }
+
+  @Test
+  fun `maps messaging publish operation type to queue publish op`() {
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-topic",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "publish",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.publish", info.op)
+    assertEquals("my-topic", info.description)
+    assertEquals(TransactionNameSource.TASK, info.transactionNameSource)
+  }
+
+  @Test
+  fun `maps messaging send operation type to queue publish op`() {
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-topic",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "send",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.publish", info.op)
+    assertEquals("my-topic", info.description)
+    assertEquals(TransactionNameSource.TASK, info.transactionNameSource)
+  }
+
+  @Test
+  fun `maps messaging process operation type to queue process op`() {
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-topic",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "process",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.process", info.op)
+    assertEquals("my-topic", info.description)
+    assertEquals(TransactionNameSource.TASK, info.transactionNameSource)
+  }
+
+  @Test
+  fun `maps messaging deliver operation type to queue process op`() {
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-topic",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "deliver",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.process", info.op)
+    assertEquals("my-topic", info.description)
+    assertEquals(TransactionNameSource.TASK, info.transactionNameSource)
+  }
+
+  @Test
+  fun `maps messaging create operation type to queue create op`() {
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-topic",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "create",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.create", info.op)
+    assertEquals("my-topic", info.description)
+    assertEquals(TransactionNameSource.TASK, info.transactionNameSource)
+  }
+
+  @Test
+  fun `maps messaging receive operation type to queue receive op`() {
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-topic",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "receive",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.receive", info.op)
+    assertEquals("my-topic", info.description)
+    assertEquals(TransactionNameSource.TASK, info.transactionNameSource)
+  }
+
+  @Test
+  fun `maps messaging settle operation type to queue settle op`() {
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "rabbitmq",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-queue",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "settle",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.settle", info.op)
+    assertEquals("my-queue", info.description)
+    assertEquals(TransactionNameSource.TASK, info.transactionNameSource)
+  }
+
+  @Test
+  fun `falls back to legacy messaging operation attribute`() {
+    @Suppress("DEPRECATION")
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "rabbitmq",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "queue-name",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION to "publish",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.publish", info.op)
+    assertEquals("queue-name", info.description)
+  }
+
+  @Test
+  fun `falls back to PRODUCER span kind when no operation attribute`() {
+    givenSpanKind(SpanKind.PRODUCER)
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-topic",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.publish", info.op)
+    assertEquals("my-topic", info.description)
+  }
+
+  @Test
+  fun `falls back to CONSUMER span kind when no operation attribute`() {
+    givenSpanKind(SpanKind.CONSUMER)
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-topic",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.process", info.op)
+    assertEquals("my-topic", info.description)
+  }
+
+  @Test
+  fun `falls back to span name as description when destination missing`() {
+    givenSpanName("my-topic publish")
+    givenAttributes(
+      mapOf(
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "kafka",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "publish",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.publish", info.op)
+    assertEquals("my-topic publish", info.description)
+  }
+
+  @Test
+  fun `messaging mapping wins over http when both attributes present and queue tracing enabled`() {
+    // Some OTel instrumentations (e.g. aws-sdk-2.2 SQS) attach both messaging and http
+    // attributes to the same span. Messaging is more specific and must win.
+    givenSpanKind(SpanKind.PRODUCER)
+    givenAttributes(
+      mapOf(
+        HttpAttributes.HTTP_REQUEST_METHOD to "POST",
+        UrlAttributes.URL_FULL to "https://sqs.us-east-1.amazonaws.com/",
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "aws.sqs",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-queue",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "publish",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = true)
+
+    assertEquals("queue.publish", info.op)
+    assertEquals("my-queue", info.description)
+    assertEquals(TransactionNameSource.TASK, info.transactionNameSource)
+  }
+
+  @Test
+  fun `http mapping wins over messaging when queue tracing disabled`() {
+    givenSpanKind(SpanKind.CLIENT)
+    givenAttributes(
+      mapOf(
+        HttpAttributes.HTTP_REQUEST_METHOD to "POST",
+        UrlAttributes.URL_FULL to "https://sqs.us-east-1.amazonaws.com/",
+        MessagingIncubatingAttributes.MESSAGING_SYSTEM to "aws.sqs",
+        MessagingIncubatingAttributes.MESSAGING_DESTINATION_NAME to "my-queue",
+        MessagingIncubatingAttributes.MESSAGING_OPERATION_TYPE to "publish",
+      )
+    )
+
+    val info = whenExtractingSpanInfo(queueTracingEnabled = false)
+
+    assertEquals("http.client", info.op)
+    assertEquals("POST https://sqs.us-east-1.amazonaws.com/", info.description)
+    assertEquals(TransactionNameSource.URL, info.transactionNameSource)
+  }
+
   @Test
   fun `uses span name as op and description if no relevant attributes`() {
     givenSpanName("span name")
@@ -289,9 +535,10 @@ class SpanDescriptionExtractorTest {
     builder.put(key as AttributeKey<Any>, value)
   }
 
-  private fun whenExtractingSpanInfo(): OtelSpanInfo {
+  private fun whenExtractingSpanInfo(queueTracingEnabled: Boolean = false): OtelSpanInfo {
     fixture.setup()
-    return SpanDescriptionExtractor().extractSpanInfo(fixture.otelSpan, fixture.sentrySpan)
+    val options = SentryOptions().apply { isEnableQueueTracing = queueTracingEnabled }
+    return SpanDescriptionExtractor().extractSpanInfo(fixture.otelSpan, fixture.sentrySpan, options)
   }
 
   private fun givenParentContext(parentContext: SpanContext) {
diff --git a/sentry-samples/sentry-samples-console/build.gradle.kts b/sentry-samples/sentry-samples-console/build.gradle.kts
index c27196e96b8..79878ab9a08 100644
--- a/sentry-samples/sentry-samples-console/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console/build.gradle.kts
@@ -36,8 +36,10 @@ dependencies {
   implementation(projects.sentry)
   implementation(projects.sentryAsyncProfiler)
   implementation(projects.sentryJcache)
+  implementation(projects.sentryKafka)
   implementation(libs.jcache)
   implementation(libs.caffeine.jcache)
+  implementation(libs.kafka.clients)
 
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(projects.sentry)
diff --git a/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java b/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java
index 0ed0646c7bc..2a45ef6902c 100644
--- a/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java
+++ b/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/Main.java
@@ -5,6 +5,7 @@
 import io.sentry.jcache.SentryJCacheWrapper;
 import io.sentry.protocol.Message;
 import io.sentry.protocol.User;
+import io.sentry.samples.console.kafka.KafkaShowcase;
 import java.util.Collections;
 import javax.cache.Cache;
 import javax.cache.CacheManager;
@@ -16,6 +17,10 @@ public class Main {
   private static long numberOfDiscardedSpansDueToOverflow = 0;
 
   public static void main(String[] args) throws InterruptedException {
+    final String kafkaBootstrapServers = System.getenv("SENTRY_SAMPLE_KAFKA_BOOTSTRAP_SERVERS");
+    final boolean kafkaEnabled =
+        kafkaBootstrapServers != null && !kafkaBootstrapServers.trim().isEmpty();
+
     Sentry.init(
         options -> {
           // NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in
@@ -95,6 +100,7 @@ public static void main(String[] args) throws InterruptedException {
 
           // Enable cache tracing to create spans for cache operations
           options.setEnableCacheTracing(true);
+          options.setEnableQueueTracing(kafkaEnabled);
 
           // Determine traces sample rate based on the sampling context
           //          options.setTracesSampler(
@@ -178,6 +184,13 @@ public static void main(String[] args) throws InterruptedException {
     // cache.remove, and cache.flush spans as children of the active transaction.
     demonstrateCacheTracing();
 
+    // Kafka queue tracing with the kafka-clients producer interceptor and manual consumer tracing.
+    //
+    // Enable with: SENTRY_SAMPLE_KAFKA_BOOTSTRAP_SERVERS=localhost:9092
+    if (kafkaEnabled) {
+      KafkaShowcase.runKafkaWithSentryTracing(kafkaBootstrapServers);
+    }
+
     // Performance feature
     //
     // Transactions collect execution time of the piece of code that's executed between the start
diff --git a/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/kafka/KafkaShowcase.java b/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/kafka/KafkaShowcase.java
new file mode 100644
index 00000000000..de85e46b25f
--- /dev/null
+++ b/sentry-samples/sentry-samples-console/src/main/java/io/sentry/samples/console/kafka/KafkaShowcase.java
@@ -0,0 +1,143 @@
+package io.sentry.samples.console.kafka;
+
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.ITransaction;
+import io.sentry.Sentry;
+import io.sentry.kafka.SentryKafkaConsumerTracing;
+import io.sentry.kafka.SentryKafkaProducer;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.Properties;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import org.apache.kafka.clients.consumer.ConsumerConfig;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.clients.consumer.ConsumerRecords;
+import org.apache.kafka.clients.consumer.KafkaConsumer;
+import org.apache.kafka.clients.producer.KafkaProducer;
+import org.apache.kafka.clients.producer.Producer;
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.clients.producer.ProducerRecord;
+import org.apache.kafka.common.serialization.StringDeserializer;
+import org.apache.kafka.common.serialization.StringSerializer;
+
+public final class KafkaShowcase {
+
+  public static final String TOPIC = "sentry-topic-console-sample";
+
+  private KafkaShowcase() {}
+
+  public static void runKafkaWithSentryTracing(final String bootstrapServers) {
+    final CountDownLatch consumedLatch = new CountDownLatch(1);
+    final Thread consumerThread = startConsumerWithSentryTracing(bootstrapServers, consumedLatch);
+    final Properties producerProperties = createProducerProperties(bootstrapServers);
+
+    final ITransaction transaction = Sentry.startTransaction("kafka-demo", "demo");
+    try (ISentryLifecycleToken ignored = transaction.makeCurrent()) {
+      // 1. Create the raw Kafka producer as you normally would.
+      final KafkaProducer<String, String> rawProducer = new KafkaProducer<>(producerProperties);
+
+      // 2. >>> Sentry instrumentation <<<
+      //    Wrap it with SentryKafkaProducer.wrap() so every send is captured as a
+      //    `queue.publish` span that closes when the broker ack callback fires.
+      final Producer<String, String> producer = SentryKafkaProducer.wrap(rawProducer);
+
+      try (producer) {
+        Thread.sleep(500);
+        producer.send(new ProducerRecord<>(TOPIC, "sentry-kafka sample message")).get();
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+      } catch (Exception ignoredException) {
+        // local broker may not be available when running the sample
+      }
+
+      try {
+        consumedLatch.await(5, TimeUnit.SECONDS);
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+      }
+    } finally {
+      consumerThread.interrupt();
+      try {
+        consumerThread.join(1000);
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+      }
+      transaction.finish();
+    }
+  }
+
+  public static Properties createProducerProperties(final String bootstrapServers) {
+    final Properties producerProperties = new Properties();
+    producerProperties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+    producerProperties.put(
+        ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
+    producerProperties.put(
+        ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
+
+    // Optional tuning for sample stability in CI/local runs.
+    producerProperties.put(ProducerConfig.MAX_BLOCK_MS_CONFIG, 2000);
+    producerProperties.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG, 2000);
+    producerProperties.put(ProducerConfig.DELIVERY_TIMEOUT_MS_CONFIG, 3000);
+
+    return producerProperties;
+  }
+
+  public static Properties createConsumerProperties(final String bootstrapServers) {
+    final Properties consumerProperties = new Properties();
+    consumerProperties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+    consumerProperties.put(
+        ConsumerConfig.GROUP_ID_CONFIG, "sentry-console-sample-" + UUID.randomUUID());
+    consumerProperties.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
+    consumerProperties.put(
+        ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
+    consumerProperties.put(
+        ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
+
+    // Optional tuning for sample stability in CI/local runs.
+    consumerProperties.put(ConsumerConfig.DEFAULT_API_TIMEOUT_MS_CONFIG, 2000);
+    consumerProperties.put(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, 2000);
+
+    return consumerProperties;
+  }
+
+  private static Thread startConsumerWithSentryTracing(
+      final String bootstrapServers, final CountDownLatch consumedLatch) {
+    final Thread consumerThread =
+        new Thread(
+            () -> {
+              final Properties consumerProperties = createConsumerProperties(bootstrapServers);
+
+              try (KafkaConsumer<String, String> consumer =
+                  new KafkaConsumer<>(consumerProperties)) {
+                consumer.subscribe(Collections.singletonList(TOPIC));
+
+                while (!Thread.currentThread().isInterrupted() && consumedLatch.getCount() > 0) {
+                  final ConsumerRecords<String, String> records =
+                      consumer.poll(Duration.ofMillis(500));
+                  for (final ConsumerRecord<String, String> record : records) {
+                    SentryKafkaConsumerTracing.withTracing(
+                        record,
+                        () -> {
+                          System.out.println(
+                              "Consumed Kafka message from "
+                                  + record.topic()
+                                  + ": "
+                                  + record.value());
+                          consumedLatch.countDown();
+                        });
+                    if (consumedLatch.getCount() == 0) {
+                      break;
+                    }
+                  }
+                }
+              } catch (Exception ignored) {
+                // local broker may not be available when running the sample
+              }
+            },
+            "sentry-kafka-sample-consumer");
+    consumerThread.start();
+    return consumerThread;
+  }
+}
diff --git a/sentry-samples/sentry-samples-console/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt b/sentry-samples/sentry-samples-console/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
index 2b009167acb..db6f54a616b 100644
--- a/sentry-samples/sentry-samples-console/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
+++ b/sentry-samples/sentry-samples-console/src/test/kotlin/io/sentry/systemtest/ConsoleApplicationSystemTest.kt
@@ -19,19 +19,7 @@ class ConsoleApplicationSystemTest {
 
   @Test
   fun `console application sends expected events when run as JAR`() {
-    val jarFile = testHelper.findJar("sentry-samples-console")
-    val process =
-      testHelper.launch(
-        jarFile,
-        mapOf(
-          "SENTRY_DSN" to testHelper.dsn,
-          "SENTRY_TRACES_SAMPLE_RATE" to "1.0",
-          "SENTRY_ENABLE_PRETTY_SERIALIZATION_OUTPUT" to "false",
-          "SENTRY_DEBUG" to "true",
-          "SENTRY_PROFILE_SESSION_SAMPLE_RATE" to "1.0",
-          "SENTRY_PROFILE_LIFECYCLE" to "TRACE",
-        ),
-      )
+    val process = launchConsoleProcess()
 
     process.waitFor(30, TimeUnit.SECONDS)
     assertEquals(0, process.exitValue())
@@ -40,6 +28,41 @@ class ConsoleApplicationSystemTest {
     verifyExpectedEvents()
   }
 
+  @Test
+  fun `console application sends kafka producer and consumer tracing when kafka is enabled`() {
+    val process =
+      launchConsoleProcess(mapOf("SENTRY_SAMPLE_KAFKA_BOOTSTRAP_SERVERS" to "localhost:9092"))
+
+    process.waitFor(30, TimeUnit.SECONDS)
+    assertEquals(0, process.exitValue())
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.transaction == "kafka-demo" &&
+        testHelper.doesTransactionContainSpanWithOp(transaction, "queue.publish")
+    }
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionHaveOp(transaction, "queue.process") &&
+        transaction.contexts.trace?.origin == "manual.queue.kafka.consumer" &&
+        transaction.contexts.trace?.data?.get("messaging.system") == "kafka"
+    }
+  }
+
+  private fun launchConsoleProcess(overrides: Map<String, String> = emptyMap()): Process {
+    val jarFile = testHelper.findJar("sentry-samples-console")
+    val env =
+      mutableMapOf(
+        "SENTRY_DSN" to testHelper.dsn,
+        "SENTRY_TRACES_SAMPLE_RATE" to "1.0",
+        "SENTRY_ENABLE_PRETTY_SERIALIZATION_OUTPUT" to "false",
+        "SENTRY_DEBUG" to "true",
+        "SENTRY_PROFILE_SESSION_SAMPLE_RATE" to "1.0",
+        "SENTRY_PROFILE_LIFECYCLE" to "TRACE",
+      )
+    env.putAll(overrides)
+    return testHelper.launch(jarFile, env)
+  }
+
   private fun verifyExpectedEvents() {
     var profilerId: SentryId? = null
     // Verify we received a "Fatal message!" event
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
index a7b2d939cdc..64ef57692c3 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
@@ -58,6 +58,10 @@ dependencies {
   implementation(projects.sentryOpentelemetry.sentryOpentelemetryAgentlessSpring)
   implementation(projects.sentryAsyncProfiler)
 
+  // kafka
+  implementation(libs.springboot4.starter.kafka)
+  implementation(projects.sentryKafka)
+
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java
new file mode 100644
index 00000000000..0c3bea3b757
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot4.queues.kafka;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile("kafka")
+public class KafkaConsumer {
+
+  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);
+
+  @KafkaListener(topics = "sentry-topic", groupId = "sentry-sample-group")
+  public void listen(String message) {
+    logger.info("Received message: {}", message);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java
new file mode 100644
index 00000000000..8c7b166fd33
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.spring.boot4.queues.kafka;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Profile("kafka")
+@RequestMapping("/kafka")
+public class KafkaController {
+
+  private final KafkaTemplate<String, String> kafkaTemplate;
+
+  public KafkaController(KafkaTemplate<String, String> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @GetMapping("/produce")
+  String produce(@RequestParam(defaultValue = "hello from sentry!") String message) {
+    kafkaTemplate.send("sentry-topic", message);
+    return "Message sent: " + message;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/resources/application-kafka.properties b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/resources/application-kafka.properties
new file mode 100644
index 00000000000..e0abadf5f9c
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/main/resources/application-kafka.properties
@@ -0,0 +1,12 @@
+# Kafka — activate with: --spring.profiles.active=kafka
+sentry.enable-queue-tracing=true
+
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=sentry-sample-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
+
+logging.level.org.apache.kafka=warn
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
new file mode 100644
index 00000000000..c401c91463e
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
@@ -0,0 +1,37 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class KafkaOtelCoexistenceSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `Sentry Kafka integration is suppressed when OTel is active`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("otel-coexistence-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.transaction == "GET /kafka/produce" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.contexts.trace?.operation == "queue.process" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.contexts.trace?.data?.get("messaging.system") == "kafka" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
index d43a628eb9a..e12b960e0fd 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
@@ -59,6 +59,10 @@ dependencies {
   implementation(projects.sentryAsyncProfiler)
   implementation(libs.otel)
 
+  // kafka
+  implementation(libs.springboot4.starter.kafka)
+  implementation(projects.sentryKafka)
+
   // cache tracing
   implementation(libs.springboot4.starter.cache)
   implementation(libs.caffeine)
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java
new file mode 100644
index 00000000000..0c3bea3b757
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot4.queues.kafka;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile("kafka")
+public class KafkaConsumer {
+
+  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);
+
+  @KafkaListener(topics = "sentry-topic", groupId = "sentry-sample-group")
+  public void listen(String message) {
+    logger.info("Received message: {}", message);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java
new file mode 100644
index 00000000000..8c7b166fd33
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.spring.boot4.queues.kafka;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Profile("kafka")
+@RequestMapping("/kafka")
+public class KafkaController {
+
+  private final KafkaTemplate<String, String> kafkaTemplate;
+
+  public KafkaController(KafkaTemplate<String, String> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @GetMapping("/produce")
+  String produce(@RequestParam(defaultValue = "hello from sentry!") String message) {
+    kafkaTemplate.send("sentry-topic", message);
+    return "Message sent: " + message;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/resources/application-kafka.properties b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/resources/application-kafka.properties
new file mode 100644
index 00000000000..e0abadf5f9c
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/main/resources/application-kafka.properties
@@ -0,0 +1,12 @@
+# Kafka — activate with: --spring.profiles.active=kafka
+sentry.enable-queue-tracing=true
+
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=sentry-sample-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
+
+logging.level.org.apache.kafka=warn
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
new file mode 100644
index 00000000000..c401c91463e
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
@@ -0,0 +1,37 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class KafkaOtelCoexistenceSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `Sentry Kafka integration is suppressed when OTel is active`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("otel-coexistence-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.transaction == "GET /kafka/produce" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.contexts.trace?.operation == "queue.process" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.contexts.trace?.data?.get("messaging.system") == "kafka" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
index d96e5602483..cdb33ecc675 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
@@ -61,6 +61,10 @@ dependencies {
   implementation(libs.springboot4.starter.cache)
   implementation(libs.caffeine)
 
+  // kafka
+  implementation(libs.springboot4.starter.kafka)
+  implementation(projects.sentryKafka)
+
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java
new file mode 100644
index 00000000000..0c3bea3b757
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaConsumer.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot4.queues.kafka;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile("kafka")
+public class KafkaConsumer {
+
+  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);
+
+  @KafkaListener(topics = "sentry-topic", groupId = "sentry-sample-group")
+  public void listen(String message) {
+    logger.info("Received message: {}", message);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java
new file mode 100644
index 00000000000..8c7b166fd33
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/main/java/io/sentry/samples/spring/boot4/queues/kafka/KafkaController.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.spring.boot4.queues.kafka;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Profile("kafka")
+@RequestMapping("/kafka")
+public class KafkaController {
+
+  private final KafkaTemplate<String, String> kafkaTemplate;
+
+  public KafkaController(KafkaTemplate<String, String> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @GetMapping("/produce")
+  String produce(@RequestParam(defaultValue = "hello from sentry!") String message) {
+    kafkaTemplate.send("sentry-topic", message);
+    return "Message sent: " + message;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/main/resources/application-kafka.properties b/sentry-samples/sentry-samples-spring-boot-4/src/main/resources/application-kafka.properties
new file mode 100644
index 00000000000..eaaa62af13b
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/main/resources/application-kafka.properties
@@ -0,0 +1,10 @@
+# Kafka — activate with: --spring.profiles.active=kafka
+sentry.enable-queue-tracing=true
+
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=sentry-sample-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
diff --git a/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt
new file mode 100644
index 00000000000..43781cf2c56
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-4/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt
@@ -0,0 +1,117 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+/**
+ * System tests for Kafka queue instrumentation.
+ *
+ * Requires:
+ * - The sample app running with `--spring.profiles.active=kafka`
+ * - A Kafka broker at localhost:9092
+ * - The mock Sentry server at localhost:8000
+ */
+class KafkaQueueSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `producer endpoint creates queue publish span`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("test-message")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "queue.publish")
+    }
+  }
+
+  @Test
+  fun `consumer creates queue process transaction`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("test-consumer-message")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    // The consumer runs asynchronously, so wait for the queue.process transaction
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionHaveOp(transaction, "queue.process")
+    }
+  }
+
+  @Test
+  fun `producer and consumer share same trace`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("trace-test-message")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    // Capture the trace ID from the producer transaction (has queue.publish span)
+    var producerTraceId: String? = null
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      if (testHelper.doesTransactionContainSpanWithOp(transaction, "queue.publish")) {
+        producerTraceId = transaction.contexts.trace?.traceId?.toString()
+        true
+      } else {
+        false
+      }
+    }
+
+    // Verify the consumer transaction has the same trace ID
+    // Use retryCount=3 since the consumer may take a moment to process
+    testHelper.ensureEnvelopeReceived(retryCount = 3) { envelopeString ->
+      val envelope =
+        testHelper.jsonSerializer.deserializeEnvelope(envelopeString.byteInputStream())
+          ?: return@ensureEnvelopeReceived false
+      val txItem =
+        envelope.items.firstOrNull { it.header.type == io.sentry.SentryItemType.Transaction }
+          ?: return@ensureEnvelopeReceived false
+      val tx =
+        txItem.getTransaction(testHelper.jsonSerializer) ?: return@ensureEnvelopeReceived false
+
+      tx.contexts.trace?.operation == "queue.process" &&
+        tx.contexts.trace?.traceId?.toString() == producerTraceId
+    }
+  }
+
+  @Test
+  fun `queue publish span has messaging attributes`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("attrs-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      val span = transaction.spans.firstOrNull { it.op == "queue.publish" }
+      if (span == null) return@ensureTransactionReceived false
+
+      val data = span.data ?: return@ensureTransactionReceived false
+      data["messaging.system"] == "kafka" && data["messaging.destination.name"] == "sentry-topic"
+    }
+  }
+
+  @Test
+  fun `queue process transaction has messaging attributes`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("process-attrs-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      if (!testHelper.doesTransactionHaveOp(transaction, "queue.process")) {
+        return@ensureTransactionReceived false
+      }
+
+      val data = transaction.contexts.trace?.data ?: return@ensureTransactionReceived false
+      data["messaging.system"] == "kafka" && data["messaging.destination.name"] == "sentry-topic"
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
index c7fc0106131..ed0af32b031 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
@@ -55,6 +55,10 @@ dependencies {
   implementation(projects.sentryAsyncProfiler)
   implementation(projects.sentryOpentelemetry.sentryOpentelemetryAgentlessSpring)
 
+  // kafka
+  implementation(libs.spring.kafka3)
+  implementation(projects.sentryKafka)
+
   // cache tracing
   implementation(libs.springboot3.starter.cache)
   implementation(libs.caffeine)
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java
new file mode 100644
index 00000000000..5931efa3a3b
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot.jakarta.queues.kafka;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile("kafka")
+public class KafkaConsumer {
+
+  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);
+
+  @KafkaListener(topics = "sentry-topic", groupId = "sentry-sample-group")
+  public void listen(String message) {
+    logger.info("Received message: {}", message);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java
new file mode 100644
index 00000000000..b17d231951d
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.spring.boot.jakarta.queues.kafka;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Profile("kafka")
+@RequestMapping("/kafka")
+public class KafkaController {
+
+  private final KafkaTemplate<String, String> kafkaTemplate;
+
+  public KafkaController(KafkaTemplate<String, String> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @GetMapping("/produce")
+  String produce(@RequestParam(defaultValue = "hello from sentry!") String message) {
+    kafkaTemplate.send("sentry-topic", message);
+    return "Message sent: " + message;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/resources/application-kafka.properties b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/resources/application-kafka.properties
new file mode 100644
index 00000000000..e0abadf5f9c
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/main/resources/application-kafka.properties
@@ -0,0 +1,12 @@
+# Kafka — activate with: --spring.profiles.active=kafka
+sentry.enable-queue-tracing=true
+
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=sentry-sample-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
+
+logging.level.org.apache.kafka=warn
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
new file mode 100644
index 00000000000..c401c91463e
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
@@ -0,0 +1,37 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class KafkaOtelCoexistenceSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `Sentry Kafka integration is suppressed when OTel is active`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("otel-coexistence-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.transaction == "GET /kafka/produce" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.contexts.trace?.operation == "queue.process" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.contexts.trace?.data?.get("messaging.system") == "kafka" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
index 767208a6082..d3d66c469b7 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
@@ -59,6 +59,10 @@ dependencies {
   implementation(libs.otel)
   implementation(projects.sentryAsyncProfiler)
 
+  // kafka
+  implementation(libs.spring.kafka3)
+  implementation(projects.sentryKafka)
+
   // cache tracing
   implementation(libs.springboot3.starter.cache)
   implementation(libs.caffeine)
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java
new file mode 100644
index 00000000000..5931efa3a3b
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot.jakarta.queues.kafka;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile("kafka")
+public class KafkaConsumer {
+
+  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);
+
+  @KafkaListener(topics = "sentry-topic", groupId = "sentry-sample-group")
+  public void listen(String message) {
+    logger.info("Received message: {}", message);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java
new file mode 100644
index 00000000000..b17d231951d
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.spring.boot.jakarta.queues.kafka;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Profile("kafka")
+@RequestMapping("/kafka")
+public class KafkaController {
+
+  private final KafkaTemplate<String, String> kafkaTemplate;
+
+  public KafkaController(KafkaTemplate<String, String> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @GetMapping("/produce")
+  String produce(@RequestParam(defaultValue = "hello from sentry!") String message) {
+    kafkaTemplate.send("sentry-topic", message);
+    return "Message sent: " + message;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/resources/application-kafka.properties b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/resources/application-kafka.properties
new file mode 100644
index 00000000000..e0abadf5f9c
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/main/resources/application-kafka.properties
@@ -0,0 +1,12 @@
+# Kafka — activate with: --spring.profiles.active=kafka
+sentry.enable-queue-tracing=true
+
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=sentry-sample-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
+
+logging.level.org.apache.kafka=warn
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
new file mode 100644
index 00000000000..c401c91463e
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
@@ -0,0 +1,37 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class KafkaOtelCoexistenceSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `Sentry Kafka integration is suppressed when OTel is active`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("otel-coexistence-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.transaction == "GET /kafka/produce" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.contexts.trace?.operation == "queue.process" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.contexts.trace?.data?.get("messaging.system") == "kafka" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
index 98f7ba434ff..ae3ef70ad70 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
@@ -62,6 +62,10 @@ dependencies {
   implementation(libs.springboot3.starter.cache)
   implementation(libs.caffeine)
 
+  // kafka
+  implementation(libs.spring.kafka3)
+  implementation(projects.sentryKafka)
+
   // OpenFeature SDK
   implementation(libs.openfeature)
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java
new file mode 100644
index 00000000000..5931efa3a3b
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaConsumer.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot.jakarta.queues.kafka;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile("kafka")
+public class KafkaConsumer {
+
+  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);
+
+  @KafkaListener(topics = "sentry-topic", groupId = "sentry-sample-group")
+  public void listen(String message) {
+    logger.info("Received message: {}", message);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java
new file mode 100644
index 00000000000..b17d231951d
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/java/io/sentry/samples/spring/boot/jakarta/queues/kafka/KafkaController.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.spring.boot.jakarta.queues.kafka;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Profile("kafka")
+@RequestMapping("/kafka")
+public class KafkaController {
+
+  private final KafkaTemplate<String, String> kafkaTemplate;
+
+  public KafkaController(KafkaTemplate<String, String> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @GetMapping("/produce")
+  String produce(@RequestParam(defaultValue = "hello from sentry!") String message) {
+    kafkaTemplate.send("sentry-topic", message);
+    return "Message sent: " + message;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application-kafka.properties b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application-kafka.properties
new file mode 100644
index 00000000000..eaaa62af13b
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application-kafka.properties
@@ -0,0 +1,10 @@
+# Kafka — activate with: --spring.profiles.active=kafka
+sentry.enable-queue-tracing=true
+
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=sentry-sample-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application.properties b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application.properties
index 60b92d369d5..20f9463aabc 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application.properties
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/main/resources/application.properties
@@ -37,6 +37,7 @@ spring.quartz.job-store-type=memory
 
 # Cache tracing
 sentry.enable-cache-tracing=true
+
 spring.cache.cache-names=todos
 spring.cache.caffeine.spec=maximumSize=500,expireAfterAccess=600s
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt
new file mode 100644
index 00000000000..43781cf2c56
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt
@@ -0,0 +1,117 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+/**
+ * System tests for Kafka queue instrumentation.
+ *
+ * Requires:
+ * - The sample app running with `--spring.profiles.active=kafka`
+ * - A Kafka broker at localhost:9092
+ * - The mock Sentry server at localhost:8000
+ */
+class KafkaQueueSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `producer endpoint creates queue publish span`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("test-message")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "queue.publish")
+    }
+  }
+
+  @Test
+  fun `consumer creates queue process transaction`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("test-consumer-message")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    // The consumer runs asynchronously, so wait for the queue.process transaction
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionHaveOp(transaction, "queue.process")
+    }
+  }
+
+  @Test
+  fun `producer and consumer share same trace`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("trace-test-message")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    // Capture the trace ID from the producer transaction (has queue.publish span)
+    var producerTraceId: String? = null
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      if (testHelper.doesTransactionContainSpanWithOp(transaction, "queue.publish")) {
+        producerTraceId = transaction.contexts.trace?.traceId?.toString()
+        true
+      } else {
+        false
+      }
+    }
+
+    // Verify the consumer transaction has the same trace ID
+    // Use retryCount=3 since the consumer may take a moment to process
+    testHelper.ensureEnvelopeReceived(retryCount = 3) { envelopeString ->
+      val envelope =
+        testHelper.jsonSerializer.deserializeEnvelope(envelopeString.byteInputStream())
+          ?: return@ensureEnvelopeReceived false
+      val txItem =
+        envelope.items.firstOrNull { it.header.type == io.sentry.SentryItemType.Transaction }
+          ?: return@ensureEnvelopeReceived false
+      val tx =
+        txItem.getTransaction(testHelper.jsonSerializer) ?: return@ensureEnvelopeReceived false
+
+      tx.contexts.trace?.operation == "queue.process" &&
+        tx.contexts.trace?.traceId?.toString() == producerTraceId
+    }
+  }
+
+  @Test
+  fun `queue publish span has messaging attributes`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("attrs-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      val span = transaction.spans.firstOrNull { it.op == "queue.publish" }
+      if (span == null) return@ensureTransactionReceived false
+
+      val data = span.data ?: return@ensureTransactionReceived false
+      data["messaging.system"] == "kafka" && data["messaging.destination.name"] == "sentry-topic"
+    }
+  }
+
+  @Test
+  fun `queue process transaction has messaging attributes`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("process-attrs-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      if (!testHelper.doesTransactionHaveOp(transaction, "queue.process")) {
+        return@ensureTransactionReceived false
+      }
+
+      val data = transaction.contexts.trace?.data ?: return@ensureTransactionReceived false
+      data["messaging.system"] == "kafka" && data["messaging.destination.name"] == "sentry-topic"
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
index d96c59ac871..f1665f513d1 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
@@ -60,6 +60,10 @@ dependencies {
   implementation(projects.sentryOpentelemetry.sentryOpentelemetryAgentlessSpring)
   implementation(projects.sentryAsyncProfiler)
 
+  // kafka
+  implementation(libs.spring.kafka2)
+  implementation(projects.sentryKafka)
+
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java
new file mode 100644
index 00000000000..013b3590a71
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot.queues.kafka;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile("kafka")
+public class KafkaConsumer {
+
+  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);
+
+  @KafkaListener(topics = "sentry-topic", groupId = "sentry-sample-group")
+  public void listen(String message) {
+    logger.info("Received message: {}", message);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java
new file mode 100644
index 00000000000..779171942d5
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.spring.boot.queues.kafka;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Profile("kafka")
+@RequestMapping("/kafka")
+public class KafkaController {
+
+  private final KafkaTemplate<String, String> kafkaTemplate;
+
+  public KafkaController(KafkaTemplate<String, String> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @GetMapping("/produce")
+  String produce(@RequestParam(defaultValue = "hello from sentry!") String message) {
+    kafkaTemplate.send("sentry-topic", message);
+    return "Message sent: " + message;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/resources/application-kafka.properties b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/resources/application-kafka.properties
new file mode 100644
index 00000000000..e0abadf5f9c
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/main/resources/application-kafka.properties
@@ -0,0 +1,12 @@
+# Kafka — activate with: --spring.profiles.active=kafka
+sentry.enable-queue-tracing=true
+
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=sentry-sample-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
+
+logging.level.org.apache.kafka=warn
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
new file mode 100644
index 00000000000..c401c91463e
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
@@ -0,0 +1,37 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class KafkaOtelCoexistenceSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `Sentry Kafka integration is suppressed when OTel is active`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("otel-coexistence-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.transaction == "GET /kafka/produce" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.contexts.trace?.operation == "queue.process" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.contexts.trace?.data?.get("messaging.system") == "kafka" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
index 1a7f62f6e74..7c84875ca07 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
@@ -56,6 +56,10 @@ dependencies {
   implementation(projects.sentryAsyncProfiler)
   implementation(libs.otel)
 
+  // kafka
+  implementation(libs.spring.kafka2)
+  implementation(projects.sentryKafka)
+
   // database query tracing
   implementation(projects.sentryJdbc)
   runtimeOnly(libs.hsqldb)
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java
new file mode 100644
index 00000000000..013b3590a71
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot.queues.kafka;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile("kafka")
+public class KafkaConsumer {
+
+  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);
+
+  @KafkaListener(topics = "sentry-topic", groupId = "sentry-sample-group")
+  public void listen(String message) {
+    logger.info("Received message: {}", message);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java
new file mode 100644
index 00000000000..779171942d5
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.spring.boot.queues.kafka;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Profile("kafka")
+@RequestMapping("/kafka")
+public class KafkaController {
+
+  private final KafkaTemplate<String, String> kafkaTemplate;
+
+  public KafkaController(KafkaTemplate<String, String> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @GetMapping("/produce")
+  String produce(@RequestParam(defaultValue = "hello from sentry!") String message) {
+    kafkaTemplate.send("sentry-topic", message);
+    return "Message sent: " + message;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/resources/application-kafka.properties b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/resources/application-kafka.properties
new file mode 100644
index 00000000000..e0abadf5f9c
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/main/resources/application-kafka.properties
@@ -0,0 +1,12 @@
+# Kafka — activate with: --spring.profiles.active=kafka
+sentry.enable-queue-tracing=true
+
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=sentry-sample-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
+
+logging.level.org.apache.kafka=warn
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
new file mode 100644
index 00000000000..c401c91463e
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/src/test/kotlin/io/sentry/systemtest/KafkaOtelCoexistenceSystemTest.kt
@@ -0,0 +1,37 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+class KafkaOtelCoexistenceSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `Sentry Kafka integration is suppressed when OTel is active`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("otel-coexistence-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.transaction == "GET /kafka/produce" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      transaction.contexts.trace?.operation == "queue.process" &&
+        transaction.contexts.trace?.origin == "auto.opentelemetry" &&
+        transaction.contexts.trace?.data?.get("messaging.system") == "kafka" &&
+        transaction.sdk?.integrationSet?.contains("SpringKafka") != true
+    }
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
index 5b89ef568e4..cc535c725e1 100644
--- a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
@@ -47,6 +47,10 @@ dependencies {
   implementation(libs.springboot.starter.cache)
   implementation(libs.springboot.starter.websocket)
   implementation(libs.caffeine)
+
+  // kafka
+  implementation(libs.spring.kafka2)
+  implementation(projects.sentryKafka)
   implementation(Config.Libs.aspectj)
   implementation(Config.Libs.kotlinReflect)
   implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
diff --git a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java
new file mode 100644
index 00000000000..013b3590a71
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaConsumer.java
@@ -0,0 +1,19 @@
+package io.sentry.samples.spring.boot.queues.kafka;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.annotation.KafkaListener;
+import org.springframework.stereotype.Component;
+
+@Component
+@Profile("kafka")
+public class KafkaConsumer {
+
+  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);
+
+  @KafkaListener(topics = "sentry-topic", groupId = "sentry-sample-group")
+  public void listen(String message) {
+    logger.info("Received message: {}", message);
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java
new file mode 100644
index 00000000000..779171942d5
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot/src/main/java/io/sentry/samples/spring/boot/queues/kafka/KafkaController.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.spring.boot.queues.kafka;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@Profile("kafka")
+@RequestMapping("/kafka")
+public class KafkaController {
+
+  private final KafkaTemplate<String, String> kafkaTemplate;
+
+  public KafkaController(KafkaTemplate<String, String> kafkaTemplate) {
+    this.kafkaTemplate = kafkaTemplate;
+  }
+
+  @GetMapping("/produce")
+  String produce(@RequestParam(defaultValue = "hello from sentry!") String message) {
+    kafkaTemplate.send("sentry-topic", message);
+    return "Message sent: " + message;
+  }
+}
diff --git a/sentry-samples/sentry-samples-spring-boot/src/main/resources/application-kafka.properties b/sentry-samples/sentry-samples-spring-boot/src/main/resources/application-kafka.properties
new file mode 100644
index 00000000000..eaaa62af13b
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot/src/main/resources/application-kafka.properties
@@ -0,0 +1,10 @@
+# Kafka — activate with: --spring.profiles.active=kafka
+sentry.enable-queue-tracing=true
+
+spring.kafka.bootstrap-servers=localhost:9092
+spring.kafka.consumer.group-id=sentry-sample-group
+spring.kafka.consumer.auto-offset-reset=earliest
+spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
+spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
+spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
diff --git a/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt b/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt
new file mode 100644
index 00000000000..43781cf2c56
--- /dev/null
+++ b/sentry-samples/sentry-samples-spring-boot/src/test/kotlin/io/sentry/systemtest/KafkaQueueSystemTest.kt
@@ -0,0 +1,117 @@
+package io.sentry.systemtest
+
+import io.sentry.systemtest.util.TestHelper
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.junit.Before
+
+/**
+ * System tests for Kafka queue instrumentation.
+ *
+ * Requires:
+ * - The sample app running with `--spring.profiles.active=kafka`
+ * - A Kafka broker at localhost:9092
+ * - The mock Sentry server at localhost:8000
+ */
+class KafkaQueueSystemTest {
+  lateinit var testHelper: TestHelper
+
+  @Before
+  fun setup() {
+    testHelper = TestHelper("http://localhost:8080")
+    testHelper.reset()
+  }
+
+  @Test
+  fun `producer endpoint creates queue publish span`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("test-message")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionContainSpanWithOp(transaction, "queue.publish")
+    }
+  }
+
+  @Test
+  fun `consumer creates queue process transaction`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("test-consumer-message")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    // The consumer runs asynchronously, so wait for the queue.process transaction
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      testHelper.doesTransactionHaveOp(transaction, "queue.process")
+    }
+  }
+
+  @Test
+  fun `producer and consumer share same trace`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("trace-test-message")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    // Capture the trace ID from the producer transaction (has queue.publish span)
+    var producerTraceId: String? = null
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      if (testHelper.doesTransactionContainSpanWithOp(transaction, "queue.publish")) {
+        producerTraceId = transaction.contexts.trace?.traceId?.toString()
+        true
+      } else {
+        false
+      }
+    }
+
+    // Verify the consumer transaction has the same trace ID
+    // Use retryCount=3 since the consumer may take a moment to process
+    testHelper.ensureEnvelopeReceived(retryCount = 3) { envelopeString ->
+      val envelope =
+        testHelper.jsonSerializer.deserializeEnvelope(envelopeString.byteInputStream())
+          ?: return@ensureEnvelopeReceived false
+      val txItem =
+        envelope.items.firstOrNull { it.header.type == io.sentry.SentryItemType.Transaction }
+          ?: return@ensureEnvelopeReceived false
+      val tx =
+        txItem.getTransaction(testHelper.jsonSerializer) ?: return@ensureEnvelopeReceived false
+
+      tx.contexts.trace?.operation == "queue.process" &&
+        tx.contexts.trace?.traceId?.toString() == producerTraceId
+    }
+  }
+
+  @Test
+  fun `queue publish span has messaging attributes`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("attrs-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      val span = transaction.spans.firstOrNull { it.op == "queue.publish" }
+      if (span == null) return@ensureTransactionReceived false
+
+      val data = span.data ?: return@ensureTransactionReceived false
+      data["messaging.system"] == "kafka" && data["messaging.destination.name"] == "sentry-topic"
+    }
+  }
+
+  @Test
+  fun `queue process transaction has messaging attributes`() {
+    val restClient = testHelper.restClient
+
+    restClient.produceKafkaMessage("process-attrs-test")
+    assertEquals(200, restClient.lastKnownStatusCode)
+
+    testHelper.ensureTransactionReceived { transaction, _ ->
+      if (!testHelper.doesTransactionHaveOp(transaction, "queue.process")) {
+        return@ensureTransactionReceived false
+      }
+
+      val data = transaction.contexts.trace?.data ?: return@ensureTransactionReceived false
+      data["messaging.system"] == "kafka" && data["messaging.destination.name"] == "sentry-topic"
+    }
+  }
+}
diff --git a/sentry-spring-7/api/sentry-spring-7.api b/sentry-spring-7/api/sentry-spring-7.api
index 71a8a022bf6..c9250b550fd 100644
--- a/sentry-spring-7/api/sentry-spring-7.api
+++ b/sentry-spring-7/api/sentry-spring-7.api
@@ -244,6 +244,29 @@ public final class io/sentry/spring7/graphql/SentrySpringSubscriptionHandler : i
 	public fun onSubscriptionResult (Ljava/lang/Object;Lio/sentry/IScopes;Lio/sentry/graphql/ExceptionReporter;Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;)Ljava/lang/Object;
 }
 
+public final class io/sentry/spring7/kafka/SentryKafkaConsumerBeanPostProcessor : org/springframework/beans/factory/config/BeanPostProcessor, org/springframework/core/PriorityOrdered {
+	public fun <init> ()V
+	public fun getOrder ()I
+	public fun postProcessAfterInitialization (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class io/sentry/spring7/kafka/SentryKafkaProducerBeanPostProcessor : org/springframework/beans/factory/config/BeanPostProcessor, org/springframework/core/PriorityOrdered {
+	public fun <init> ()V
+	public fun getOrder ()I
+	public fun postProcessAfterInitialization (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class io/sentry/spring7/kafka/SentryKafkaRecordInterceptor : org/springframework/kafka/listener/RecordInterceptor {
+	public fun <init> (Lio/sentry/IScopes;)V
+	public fun <init> (Lio/sentry/IScopes;Lorg/springframework/kafka/listener/RecordInterceptor;)V
+	public fun afterRecord (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun clearThreadState (Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun failure (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Ljava/lang/Exception;Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun intercept (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Lorg/apache/kafka/clients/consumer/Consumer;)Lorg/apache/kafka/clients/consumer/ConsumerRecord;
+	public fun setupThreadState (Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun success (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Lorg/apache/kafka/clients/consumer/Consumer;)V
+}
+
 public class io/sentry/spring7/opentelemetry/SentryOpenTelemetryAgentWithoutAutoInitConfiguration {
 	public fun <init> ()V
 	public fun sentryOpenTelemetryOptionsConfiguration ()Lio/sentry/Sentry$OptionsConfiguration;
diff --git a/sentry-spring-7/build.gradle.kts b/sentry-spring-7/build.gradle.kts
index 8102909afb0..ae8269e7825 100644
--- a/sentry-spring-7/build.gradle.kts
+++ b/sentry-spring-7/build.gradle.kts
@@ -43,10 +43,12 @@ dependencies {
   compileOnly(libs.slf4j.api)
   compileOnly(libs.springboot4.starter.graphql)
   compileOnly(libs.springboot4.starter.quartz)
+  compileOnly(libs.spring.kafka4)
 
   compileOnly(Config.Libs.springWebflux)
   compileOnly(projects.sentryGraphql)
   compileOnly(projects.sentryGraphql22)
+  compileOnly(projects.sentryKafka)
   compileOnly(projects.sentryQuartz)
   compileOnly(projects.sentryOpentelemetry.sentryOpentelemetryAgentcustomization)
   compileOnly(projects.sentryOpentelemetry.sentryOpentelemetryBootstrap)
@@ -60,6 +62,7 @@ dependencies {
   // tests
   testImplementation(projects.sentryTestSupport)
   testImplementation(projects.sentryGraphql)
+  testImplementation(projects.sentryKafka)
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(libs.awaitility.kotlin.spring7)
   testImplementation(libs.context.propagation)
@@ -69,6 +72,7 @@ dependencies {
   testImplementation(libs.mockito.inline)
   testImplementation(libs.springboot4.starter.aspectj)
   testImplementation(libs.springboot4.starter.graphql)
+  testImplementation(libs.spring.kafka4)
   testImplementation(libs.springboot4.starter.security)
   testImplementation(libs.springboot4.starter.test)
   testImplementation(libs.springboot4.starter.web)
diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaConsumerBeanPostProcessor.java b/sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaConsumerBeanPostProcessor.java
new file mode 100644
index 00000000000..069330a4247
--- /dev/null
+++ b/sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaConsumerBeanPostProcessor.java
@@ -0,0 +1,98 @@
+package io.sentry.spring7.kafka;
+
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryLevel;
+import java.lang.reflect.Field;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.core.Ordered;
+import org.springframework.core.PriorityOrdered;
+import org.springframework.kafka.config.AbstractKafkaListenerContainerFactory;
+import org.springframework.kafka.listener.RecordInterceptor;
+
+/**
+ * Registers {@link SentryKafkaRecordInterceptor} on {@link AbstractKafkaListenerContainerFactory}
+ * beans. If an existing {@link RecordInterceptor} is already set, it is composed as a delegate.
+ */
+@ApiStatus.Internal
+public final class SentryKafkaConsumerBeanPostProcessor
+    implements BeanPostProcessor, PriorityOrdered {
+
+  private static final @NotNull String RECORD_INTERCEPTOR_FIELD_NAME = "recordInterceptor";
+
+  private final @NotNull String recordInterceptorFieldName;
+
+  public SentryKafkaConsumerBeanPostProcessor() {
+    this(RECORD_INTERCEPTOR_FIELD_NAME);
+  }
+
+  SentryKafkaConsumerBeanPostProcessor(final @NotNull String recordInterceptorFieldName) {
+    this.recordInterceptorFieldName = recordInterceptorFieldName;
+  }
+
+  private static final class InterceptorReadFailedException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    InterceptorReadFailedException(final @NotNull Throwable cause) {
+      super(cause);
+    }
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public @NotNull Object postProcessAfterInitialization(
+      final @NotNull Object bean, final @NotNull String beanName) throws BeansException {
+    if (bean instanceof AbstractKafkaListenerContainerFactory) {
+      final @NotNull AbstractKafkaListenerContainerFactory<?, ?, ?> factory =
+          (AbstractKafkaListenerContainerFactory<?, ?, ?>) bean;
+
+      final @Nullable RecordInterceptor<?, ?> existing;
+      try {
+        existing = getExistingInterceptor(factory);
+      } catch (InterceptorReadFailedException e) {
+        ScopesAdapter.getInstance()
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.ERROR,
+                e,
+                "Sentry Kafka consumer tracing disabled for factory '%s' \u2014 could not read "
+                    + "existing recordInterceptor via reflection. Refusing to install Sentry's "
+                    + "interceptor to avoid overwriting a customer-configured RecordInterceptor.",
+                beanName);
+        return bean;
+      }
+
+      if (existing instanceof SentryKafkaRecordInterceptor) {
+        return bean;
+      }
+
+      @SuppressWarnings("rawtypes")
+      final RecordInterceptor sentryInterceptor =
+          new SentryKafkaRecordInterceptor<>(ScopesAdapter.getInstance(), existing);
+      factory.setRecordInterceptor(sentryInterceptor);
+    }
+    return bean;
+  }
+
+  private @Nullable RecordInterceptor<?, ?> getExistingInterceptor(
+      final @NotNull AbstractKafkaListenerContainerFactory<?, ?, ?> factory)
+      throws InterceptorReadFailedException {
+    try {
+      final @NotNull Field field =
+          AbstractKafkaListenerContainerFactory.class.getDeclaredField(recordInterceptorFieldName);
+      field.setAccessible(true);
+      return (RecordInterceptor<?, ?>) field.get(factory);
+    } catch (NoSuchFieldException | IllegalAccessException | RuntimeException e) {
+      throw new InterceptorReadFailedException(e);
+    }
+  }
+
+  @Override
+  public int getOrder() {
+    return Ordered.LOWEST_PRECEDENCE;
+  }
+}
diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaProducerBeanPostProcessor.java b/sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaProducerBeanPostProcessor.java
new file mode 100644
index 00000000000..eff0b4154bb
--- /dev/null
+++ b/sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaProducerBeanPostProcessor.java
@@ -0,0 +1,76 @@
+package io.sentry.spring7.kafka;
+
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryLevel;
+import io.sentry.kafka.SentryKafkaProducer;
+import org.apache.kafka.clients.producer.Producer;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.core.Ordered;
+import org.springframework.core.PriorityOrdered;
+import org.springframework.kafka.core.ProducerFactory;
+import org.springframework.kafka.core.ProducerPostProcessor;
+
+/**
+ * Installs a {@link ProducerPostProcessor} on every {@link ProducerFactory} bean so that each
+ * {@link Producer} created by Spring Kafka is wrapped via {@link SentryKafkaProducer#wrap
+ * SentryKafkaProducer.wrap(Producer)}.
+ *
+ * <p>The wrapper records a {@code queue.publish} span around each {@code send(...)} that finishes
+ * when the broker ack callback fires, giving a real producer-send lifecycle span. {@code
+ * KafkaTemplate} beans are left untouched, so all customer-configured listeners, interceptors and
+ * observation settings are preserved.
+ *
+ * <p>Note: {@link ProducerFactory#addPostProcessor(ProducerPostProcessor)} is a default method on
+ * the interface that is a no-op unless overridden. Custom factories that do not extend {@code
+ * DefaultKafkaProducerFactory} will not receive Sentry producer instrumentation; a warning is
+ * logged at startup in that case.
+ */
+@ApiStatus.Internal
+public final class SentryKafkaProducerBeanPostProcessor
+    implements BeanPostProcessor, PriorityOrdered {
+
+  @Override
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public @NotNull Object postProcessAfterInitialization(
+      final @NotNull Object bean, final @NotNull String beanName) throws BeansException {
+    if (bean instanceof ProducerFactory) {
+      final @NotNull ProducerFactory factory = (ProducerFactory) bean;
+      final @NotNull SentryProducerPostProcessor pp = new SentryProducerPostProcessor<>();
+      factory.addPostProcessor(pp);
+      if (!factory.getPostProcessors().contains(pp)) {
+        ScopesAdapter.getInstance()
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.WARNING,
+                "Sentry Kafka producer tracing not active for ProducerFactory '%s' (%s). "
+                    + "addPostProcessor() was not honored — the factory may not extend "
+                    + "DefaultKafkaProducerFactory. Wrap producers manually with "
+                    + "SentryKafkaProducer.wrap(producer).",
+                beanName,
+                factory.getClass().getName());
+      }
+    }
+    return bean;
+  }
+
+  @Override
+  public int getOrder() {
+    return Ordered.LOWEST_PRECEDENCE;
+  }
+
+  /**
+   * Marker {@link ProducerPostProcessor} that wraps the freshly created Kafka {@link Producer} via
+   * {@link SentryKafkaProducer#wrap}.
+   */
+  static final class SentryProducerPostProcessor<K, V> implements ProducerPostProcessor<K, V> {
+    @Override
+    public @NotNull Producer<K, V> apply(final @NotNull Producer<K, V> producer) {
+      return SentryKafkaProducer.wrap(
+          producer, ScopesAdapter.getInstance(), "auto.queue.spring7.kafka.producer");
+    }
+  }
+}
diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaRecordInterceptor.java b/sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaRecordInterceptor.java
new file mode 100644
index 00000000000..b2b4d20b948
--- /dev/null
+++ b/sentry-spring-7/src/main/java/io/sentry/spring7/kafka/SentryKafkaRecordInterceptor.java
@@ -0,0 +1,292 @@
+package io.sentry.spring7.kafka;
+
+import io.sentry.BaggageHeader;
+import io.sentry.DateUtils;
+import io.sentry.IScopes;
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.ITransaction;
+import io.sentry.SentryLevel;
+import io.sentry.SentryTraceHeader;
+import io.sentry.SpanDataConvention;
+import io.sentry.SpanStatus;
+import io.sentry.TransactionContext;
+import io.sentry.TransactionOptions;
+import io.sentry.kafka.SentryKafkaProducer;
+import io.sentry.util.SpanUtils;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.common.header.Header;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.kafka.listener.RecordInterceptor;
+import org.springframework.kafka.support.KafkaHeaders;
+
+/**
+ * A {@link RecordInterceptor} that creates {@code queue.process} transactions for incoming Kafka
+ * records with distributed tracing support.
+ */
+@ApiStatus.Internal
+public final class SentryKafkaRecordInterceptor<K, V> implements RecordInterceptor<K, V> {
+
+  static final String TRACE_ORIGIN = "auto.queue.spring7.kafka.consumer";
+
+  private final @NotNull IScopes scopes;
+  private final @Nullable RecordInterceptor<K, V> delegate;
+
+  private static final @NotNull ThreadLocal<SentryRecordContext> currentContext =
+      new ThreadLocal<>();
+
+  public SentryKafkaRecordInterceptor(final @NotNull IScopes scopes) {
+    this(scopes, null);
+  }
+
+  public SentryKafkaRecordInterceptor(
+      final @NotNull IScopes scopes, final @Nullable RecordInterceptor<K, V> delegate) {
+    this.scopes = scopes;
+    this.delegate = delegate;
+  }
+
+  @Override
+  public @Nullable ConsumerRecord<K, V> intercept(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    if (!scopes.getOptions().isEnableQueueTracing() || isIgnored()) {
+      return delegateIntercept(record, consumer);
+    }
+
+    try {
+      finishStaleContext();
+
+      final @NotNull IScopes forkedScopes = scopes.forkedRootScopes("SentryKafkaRecordInterceptor");
+      final @NotNull ISentryLifecycleToken lifecycleToken = forkedScopes.makeCurrent();
+      currentContext.set(new SentryRecordContext(lifecycleToken, null));
+
+      final @Nullable TransactionContext transactionContext = continueTrace(forkedScopes, record);
+
+      final @Nullable ITransaction transaction =
+          startTransaction(forkedScopes, record, transactionContext);
+      currentContext.set(new SentryRecordContext(lifecycleToken, transaction));
+    } catch (Throwable t) {
+      scopes.getOptions().getLogger().log(SentryLevel.ERROR, "Unable to wrap Kafka consumer.", t);
+    }
+    return delegateIntercept(record, consumer);
+  }
+
+  @Override
+  public void success(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    try {
+      if (delegate != null) {
+        delegate.success(record, consumer);
+      }
+    } finally {
+      finishSpan(SpanStatus.OK, null);
+    }
+  }
+
+  @Override
+  public void failure(
+      final @NotNull ConsumerRecord<K, V> record,
+      final @NotNull Exception exception,
+      final @NotNull Consumer<K, V> consumer) {
+    try {
+      if (delegate != null) {
+        delegate.failure(record, exception, consumer);
+      }
+    } finally {
+      finishSpan(SpanStatus.INTERNAL_ERROR, exception);
+    }
+  }
+
+  @Override
+  public void afterRecord(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    if (delegate != null) {
+      delegate.afterRecord(record, consumer);
+    }
+  }
+
+  @Override
+  public void setupThreadState(final @NotNull Consumer<?, ?> consumer) {
+    if (delegate != null) {
+      delegate.setupThreadState(consumer);
+    }
+  }
+
+  @Override
+  public void clearThreadState(final @NotNull Consumer<?, ?> consumer) {
+    try {
+      finishStaleContext();
+    } finally {
+      if (delegate != null) {
+        delegate.clearThreadState(consumer);
+      }
+    }
+  }
+
+  private boolean isIgnored() {
+    return SpanUtils.isIgnored(scopes.getOptions().getIgnoredSpanOrigins(), TRACE_ORIGIN);
+  }
+
+  private @Nullable ConsumerRecord<K, V> delegateIntercept(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    if (delegate != null) {
+      return delegate.intercept(record, consumer);
+    }
+    return record;
+  }
+
+  private @Nullable TransactionContext continueTrace(
+      final @NotNull IScopes forkedScopes, final @NotNull ConsumerRecord<K, V> record) {
+    final @Nullable String sentryTrace = headerValue(record, SentryTraceHeader.SENTRY_TRACE_HEADER);
+    final @Nullable List<String> baggageHeaders =
+        headerValues(record, BaggageHeader.BAGGAGE_HEADER);
+    return forkedScopes.continueTrace(sentryTrace, baggageHeaders);
+  }
+
+  private @Nullable ITransaction startTransaction(
+      final @NotNull IScopes forkedScopes,
+      final @NotNull ConsumerRecord<K, V> record,
+      final @Nullable TransactionContext transactionContext) {
+    if (!forkedScopes.getOptions().isTracingEnabled()) {
+      return null;
+    }
+
+    final @NotNull TransactionContext txContext =
+        transactionContext != null
+            ? transactionContext
+            : new TransactionContext(record.topic(), "queue.process");
+    txContext.setName(record.topic());
+    txContext.setOperation("queue.process");
+
+    final @NotNull TransactionOptions txOptions = new TransactionOptions();
+    txOptions.setOrigin(TRACE_ORIGIN);
+    txOptions.setBindToScope(true);
+
+    final @NotNull ITransaction transaction = forkedScopes.startTransaction(txContext, txOptions);
+
+    if (transaction.isNoOp()) {
+      return null;
+    }
+
+    transaction.setData(SpanDataConvention.MESSAGING_SYSTEM, "kafka");
+    transaction.setData(SpanDataConvention.MESSAGING_DESTINATION_NAME, record.topic());
+
+    final @Nullable String messageId = headerValue(record, "messaging.message.id");
+    if (messageId != null) {
+      transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_ID, messageId);
+    }
+
+    final int bodySize = record.serializedValueSize();
+    if (bodySize >= 0) {
+      transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE, bodySize);
+    }
+
+    final @Nullable Integer retryCount = retryCount(record);
+    if (retryCount != null) {
+      transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT, retryCount);
+    }
+
+    final @Nullable String enqueuedTimeStr =
+        headerValue(record, SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER);
+    if (enqueuedTimeStr != null) {
+      try {
+        final double enqueuedTimeSeconds = Double.parseDouble(enqueuedTimeStr);
+        final double nowSeconds = DateUtils.millisToSeconds(System.currentTimeMillis());
+        final long latencyMs = (long) ((nowSeconds - enqueuedTimeSeconds) * 1000);
+        if (latencyMs >= 0) {
+          transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_RECEIVE_LATENCY, latencyMs);
+        }
+      } catch (NumberFormatException ignored) {
+        // ignore malformed header
+      }
+    }
+
+    return transaction;
+  }
+
+  private @Nullable Integer retryCount(final @NotNull ConsumerRecord<K, V> record) {
+    final @Nullable Header header = record.headers().lastHeader(KafkaHeaders.DELIVERY_ATTEMPT);
+    if (header == null) {
+      return null;
+    }
+
+    final byte[] value = header.value();
+    if (value == null || value.length != Integer.BYTES) {
+      return null;
+    }
+
+    final int attempt = ByteBuffer.wrap(value).getInt();
+    if (attempt <= 0) {
+      return null;
+    }
+
+    return attempt - 1;
+  }
+
+  private void finishStaleContext() {
+    if (currentContext.get() != null) {
+      finishSpan(SpanStatus.UNKNOWN, null);
+    }
+  }
+
+  private void finishSpan(final @NotNull SpanStatus status, final @Nullable Throwable throwable) {
+    final @Nullable SentryRecordContext ctx = currentContext.get();
+    if (ctx == null) {
+      return;
+    }
+    currentContext.remove();
+
+    try {
+      final @Nullable ITransaction transaction = ctx.transaction;
+      if (transaction != null) {
+        transaction.setStatus(status);
+        if (throwable != null) {
+          transaction.setThrowable(throwable);
+        }
+        transaction.finish();
+      }
+    } finally {
+      ctx.lifecycleToken.close();
+    }
+  }
+
+  private @Nullable String headerValue(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull String headerName) {
+    final @Nullable Header header = record.headers().lastHeader(headerName);
+    if (header == null || header.value() == null) {
+      return null;
+    }
+    return new String(header.value(), StandardCharsets.UTF_8);
+  }
+
+  private @Nullable List<String> headerValues(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull String headerName) {
+    @Nullable List<String> values = null;
+    for (final @NotNull Header header : record.headers().headers(headerName)) {
+      if (header.value() != null) {
+        if (values == null) {
+          values = new ArrayList<>();
+        }
+        values.add(new String(header.value(), StandardCharsets.UTF_8));
+      }
+    }
+    return values;
+  }
+
+  private static final class SentryRecordContext {
+    final @NotNull ISentryLifecycleToken lifecycleToken;
+    final @Nullable ITransaction transaction;
+
+    SentryRecordContext(
+        final @NotNull ISentryLifecycleToken lifecycleToken,
+        final @Nullable ITransaction transaction) {
+      this.lifecycleToken = lifecycleToken;
+      this.transaction = transaction;
+    }
+  }
+}
diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt
new file mode 100644
index 00000000000..e5eb3b55292
--- /dev/null
+++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt
@@ -0,0 +1,124 @@
+package io.sentry.spring7.kafka
+
+import io.sentry.Sentry
+import io.sentry.test.initForTest
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory
+import org.springframework.kafka.core.ConsumerFactory
+import org.springframework.kafka.listener.RecordInterceptor
+
+class SentryKafkaConsumerBeanPostProcessorTest {
+
+  @BeforeTest
+  fun setup() {
+    initForTest { it.dsn = "https://key@sentry.io/proj" }
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+  }
+
+  @Test
+  fun `wraps ConcurrentKafkaListenerContainerFactory with SentryKafkaRecordInterceptor`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.setConsumerFactory(consumerFactory)
+
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    // Verify via reflection that the interceptor was set
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    val interceptor = field.get(factory)
+    assertTrue(interceptor is SentryKafkaRecordInterceptor<*, *>)
+  }
+
+  @Test
+  fun `does not double-wrap when SentryKafkaRecordInterceptor already set`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.setConsumerFactory(consumerFactory)
+
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+    // First wrap
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    val firstInterceptor = field.get(factory)
+
+    // Second wrap — should be idempotent
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+    val secondInterceptor = field.get(factory)
+
+    assertSame(firstInterceptor, secondInterceptor)
+  }
+
+  @Test
+  fun `does not wrap non-factory beans`() {
+    val someBean = "not a factory"
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(someBean, "someBean")
+
+    assertSame(someBean, result)
+  }
+
+  @Test
+  fun `chains existing customer RecordInterceptor as delegate`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.setConsumerFactory(consumerFactory)
+
+    val customerInterceptor = RecordInterceptor<String, String> { record, _ -> record }
+    factory.setRecordInterceptor(customerInterceptor)
+
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    val installed = field.get(factory)
+    assertTrue(
+      installed is SentryKafkaRecordInterceptor<*, *>,
+      "expected SentryKafkaRecordInterceptor, got ${installed?.javaClass}",
+    )
+
+    val delegateField = SentryKafkaRecordInterceptor::class.java.getDeclaredField("delegate")
+    delegateField.isAccessible = true
+    assertSame(
+      customerInterceptor,
+      delegateField.get(installed),
+      "customer interceptor must be preserved as delegate",
+    )
+  }
+
+  @Test
+  fun `skips installation when reflection fails and preserves customer interceptor`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.setConsumerFactory(consumerFactory)
+    val customerInterceptor = RecordInterceptor<String, String> { record, _ -> record }
+    factory.setRecordInterceptor(customerInterceptor)
+
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    assertSame(customerInterceptor, field.get(factory))
+
+    val processor = SentryKafkaConsumerBeanPostProcessor("missingRecordInterceptor")
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    assertSame(
+      customerInterceptor,
+      field.get(factory),
+      "customer interceptor must remain installed when Sentry cannot read it",
+    )
+  }
+}
diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaProducerBeanPostProcessorTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaProducerBeanPostProcessorTest.kt
new file mode 100644
index 00000000000..d11ac1e6c1b
--- /dev/null
+++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaProducerBeanPostProcessorTest.kt
@@ -0,0 +1,109 @@
+package io.sentry.spring7.kafka
+
+import io.sentry.Sentry
+import io.sentry.test.initForTest
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.apache.kafka.clients.producer.Producer
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.springframework.kafka.core.DefaultKafkaProducerFactory
+import org.springframework.kafka.core.ProducerFactory
+import org.springframework.kafka.core.ProducerPostProcessor
+
+class SentryKafkaProducerBeanPostProcessorTest {
+
+  @BeforeTest
+  fun setup() {
+    initForTest { it.dsn = "https://key@sentry.io/proj" }
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+  }
+
+  @Test
+  fun `registers Sentry post-processor on ProducerFactory`() {
+    val factory = mock<ProducerFactory<String, String>>()
+    val pp = SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<String, String>()
+    whenever(factory.postProcessors).thenReturn(listOf(pp))
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    processor.postProcessAfterInitialization(factory, "kafkaProducerFactory")
+
+    val captor = argumentCaptor<ProducerPostProcessor<String, String>>()
+    verify(factory).addPostProcessor(captor.capture())
+    assertTrue(
+      captor.firstValue is SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<*, *>
+    )
+  }
+
+  @Test
+  fun `does not throw when addPostProcessor is a no-op (default interface method)`() {
+    // Factory using the default no-op addPostProcessor / getPostProcessors
+    val factory = mock<ProducerFactory<String, String>>()
+    whenever(factory.postProcessors).thenReturn(emptyList())
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    // Should complete without throwing, and log a warning via ScopesAdapter
+    processor.postProcessAfterInitialization(factory, "myFactory")
+
+    verify(factory).addPostProcessor(any())
+  }
+
+  @Test
+  fun `does not modify non-ProducerFactory beans`() {
+    val someBean = "not a producer factory"
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(someBean, "someBean")
+
+    assertSame(someBean, result)
+  }
+
+  @Test
+  fun `returns the same bean instance`() {
+    val factory = mock<ProducerFactory<String, String>>()
+    val pp = SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<String, String>()
+    whenever(factory.postProcessors).thenReturn(listOf(pp))
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(factory, "kafkaProducerFactory")
+
+    assertSame(factory, result, "BPP must return the same bean, not a replacement")
+  }
+
+  @Test
+  fun `registered post-processor wraps producers via SentryKafkaProducer wrap`() {
+    val pp = SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<String, String>()
+    val raw = mock<Producer<String, String>>()
+
+    val wrapped = pp.apply(raw)
+
+    assertTrue(java.lang.reflect.Proxy.isProxyClass(wrapped.javaClass))
+  }
+
+  @Test
+  fun `integrates with DefaultKafkaProducerFactory addPostProcessor contract`() {
+    // Sanity check against the real Spring Kafka API surface — DefaultKafkaProducerFactory
+    // honors addPostProcessor and exposes it via getPostProcessors().
+    val factory = DefaultKafkaProducerFactory<String, String>(emptyMap())
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    processor.postProcessAfterInitialization(factory, "kafkaProducerFactory")
+
+    assertEquals(1, factory.postProcessors.size)
+    assertTrue(
+      factory.postProcessors.first()
+        is SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<*, *>
+    )
+  }
+}
diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaRecordInterceptorTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaRecordInterceptorTest.kt
new file mode 100644
index 00000000000..2738f99f4df
--- /dev/null
+++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/kafka/SentryKafkaRecordInterceptorTest.kt
@@ -0,0 +1,473 @@
+package io.sentry.spring7.kafka
+
+import io.sentry.BaggageHeader
+import io.sentry.IScopes
+import io.sentry.ISentryLifecycleToken
+import io.sentry.Sentry
+import io.sentry.SentryOptions
+import io.sentry.SentryTraceHeader
+import io.sentry.SentryTracer
+import io.sentry.SpanDataConvention
+import io.sentry.TransactionContext
+import io.sentry.kafka.SentryKafkaProducer
+import io.sentry.test.initForTest
+import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
+import java.util.Optional
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.apache.kafka.clients.consumer.Consumer
+import org.apache.kafka.clients.consumer.ConsumerRecord
+import org.apache.kafka.common.header.internals.RecordHeaders
+import org.apache.kafka.common.record.TimestampType
+import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.springframework.kafka.listener.RecordInterceptor
+import org.springframework.kafka.support.KafkaHeaders
+
+class SentryKafkaRecordInterceptorTest {
+
+  private lateinit var scopes: IScopes
+  private lateinit var forkedScopes: IScopes
+  private lateinit var options: SentryOptions
+  private lateinit var consumer: Consumer<String, String>
+  private lateinit var lifecycleToken: ISentryLifecycleToken
+  private lateinit var transaction: SentryTracer
+
+  @BeforeTest
+  fun setup() {
+    initForTest { it.dsn = "https://key@sentry.io/proj" }
+    scopes = mock()
+    consumer = mock()
+    lifecycleToken = mock()
+    options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        isEnableQueueTracing = true
+        tracesSampleRate = 1.0
+      }
+    whenever(scopes.options).thenReturn(options)
+    whenever(scopes.isEnabled).thenReturn(true)
+
+    forkedScopes = mock()
+    whenever(scopes.forkedRootScopes(any())).thenReturn(forkedScopes)
+    whenever(forkedScopes.options).thenReturn(options)
+    whenever(forkedScopes.makeCurrent()).thenReturn(lifecycleToken)
+
+    transaction = SentryTracer(TransactionContext("queue.process", "queue.process"), forkedScopes)
+    whenever(forkedScopes.startTransaction(any<TransactionContext>(), any()))
+      .thenReturn(transaction)
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+  }
+
+  private fun createRecord(
+    topic: String = "my-topic",
+    headers: RecordHeaders = RecordHeaders(),
+    serializedValueSize: Int = -1,
+  ): ConsumerRecord<String, String> {
+    return ConsumerRecord(
+      topic,
+      0,
+      0L,
+      System.currentTimeMillis(),
+      TimestampType.CREATE_TIME,
+      3,
+      serializedValueSize,
+      "key",
+      "value",
+      headers,
+      Optional.empty(),
+    )
+  }
+
+  private fun createRecordWithHeaders(
+    sentryTrace: String? = null,
+    baggage: String? = null,
+    baggageHeaders: List<String>? = null,
+    enqueuedTime: String? = null,
+    deliveryAttempt: Int? = null,
+  ): ConsumerRecord<String, String> {
+    val headers = RecordHeaders()
+    sentryTrace?.let {
+      headers.add(SentryTraceHeader.SENTRY_TRACE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    baggage?.let {
+      headers.add(BaggageHeader.BAGGAGE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    baggageHeaders?.forEach {
+      headers.add(BaggageHeader.BAGGAGE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    enqueuedTime?.let {
+      headers.add(
+        SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER,
+        it.toByteArray(StandardCharsets.UTF_8),
+      )
+    }
+    deliveryAttempt?.let {
+      headers.add(
+        KafkaHeaders.DELIVERY_ATTEMPT,
+        ByteBuffer.allocate(Int.SIZE_BYTES).putInt(it).array(),
+      )
+    }
+    val record = ConsumerRecord("my-topic", 0, 0L, "key", "value")
+    headers.forEach { record.headers().add(it) }
+    return record
+  }
+
+  @Test
+  fun `intercept forks root scopes`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    verify(scopes).forkedRootScopes("SentryKafkaRecordInterceptor")
+    verify(forkedScopes).makeCurrent()
+    verify(forkedScopes)
+      .startTransaction(
+        org.mockito.kotlin.check<TransactionContext> {
+          assertEquals("my-topic", it.name)
+          assertEquals("queue.process", it.operation)
+        },
+        any(),
+      )
+  }
+
+  @Test
+  fun `intercept continues trace from headers`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val sentryTraceValue = "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1"
+    val record = createRecordWithHeaders(sentryTrace = sentryTraceValue)
+
+    interceptor.intercept(record, consumer)
+
+    verify(forkedScopes)
+      .continueTrace(org.mockito.kotlin.eq(sentryTraceValue), org.mockito.kotlin.isNull())
+  }
+
+  @Test
+  fun `intercept calls continueTrace with null when no headers`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    verify(forkedScopes).continueTrace(org.mockito.kotlin.isNull(), org.mockito.kotlin.isNull())
+  }
+
+  @Test
+  fun `intercept passes all baggage headers to continueTrace`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val sentryTraceValue = "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1"
+    val record =
+      createRecordWithHeaders(
+        sentryTrace = sentryTraceValue,
+        baggageHeaders = listOf("third=party", "sentry-sample_rate=1"),
+      )
+
+    interceptor.intercept(record, consumer)
+
+    verify(forkedScopes)
+      .continueTrace(
+        org.mockito.kotlin.eq(sentryTraceValue),
+        org.mockito.kotlin.eq(listOf("third=party", "sentry-sample_rate=1")),
+      )
+  }
+
+  @Test
+  fun `sets body size from serializedValueSize`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord(serializedValueSize = 42)
+
+    interceptor.intercept(record, consumer)
+
+    assertEquals(42, transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE))
+  }
+
+  @Test
+  fun `does not set body size when serializedValueSize is negative`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord(serializedValueSize = -1)
+
+    interceptor.intercept(record, consumer)
+
+    assertNull(transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE))
+  }
+
+  @Test
+  fun `sets retry count from delivery attempt header`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecordWithHeaders(deliveryAttempt = 3)
+
+    interceptor.intercept(record, consumer)
+
+    assertEquals(2, transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT))
+  }
+
+  @Test
+  fun `does not set retry count when delivery attempt header is missing`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    assertNull(transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT))
+  }
+
+  @Test
+  fun `sets receive latency from enqueued time in epoch seconds`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val enqueuedTime = (System.currentTimeMillis() / 1000.0 - 1.0).toString()
+    val record = createRecordWithHeaders(enqueuedTime = enqueuedTime)
+
+    interceptor.intercept(record, consumer)
+
+    val latency = transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_RECEIVE_LATENCY)
+    assertTrue(latency is Long && latency >= 0)
+  }
+
+  @Test
+  fun `does not create span when queue tracing is disabled`() {
+    options.isEnableQueueTracing = false
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    val result = interceptor.intercept(record, consumer)
+
+    verify(scopes, never()).forkedRootScopes(any())
+    verify(forkedScopes, never()).makeCurrent()
+    assertEquals(record, result)
+  }
+
+  @Test
+  fun `does not create span when origin is ignored`() {
+    options.setIgnoredSpanOrigins(listOf(SentryKafkaRecordInterceptor.TRACE_ORIGIN))
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    val result = interceptor.intercept(record, consumer)
+
+    verify(scopes, never()).forkedRootScopes(any())
+    verify(forkedScopes, never()).makeCurrent()
+    assertEquals(record, result)
+  }
+
+  @Test
+  fun `delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    whenever(delegate.intercept(record, consumer)).thenReturn(record)
+
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    interceptor.intercept(record, consumer)
+
+    verify(delegate).intercept(record, consumer)
+  }
+
+  @Test
+  fun `success finishes transaction and delegates`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+    interceptor.success(record, consumer)
+
+    verify(delegate).success(record, consumer)
+  }
+
+  @Test
+  fun `failure finishes transaction with error and delegates`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+    val exception = RuntimeException("processing failed")
+
+    interceptor.intercept(record, consumer)
+    interceptor.failure(record, exception, consumer)
+
+    verify(delegate).failure(record, exception, consumer)
+  }
+
+  @Test
+  fun `afterRecord delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+
+    interceptor.afterRecord(record, consumer)
+
+    verify(delegate).afterRecord(record, consumer)
+  }
+
+  @Test
+  fun `trace origin is set correctly`() {
+    assertEquals("auto.queue.spring7.kafka.consumer", SentryKafkaRecordInterceptor.TRACE_ORIGIN)
+  }
+
+  @Test
+  fun `clearThreadState cleans up stale context`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    interceptor.clearThreadState(consumer)
+
+    verify(lifecycleToken).close()
+  }
+
+  @Test
+  fun `clearThreadState is no-op when no context exists`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+
+    // should not throw
+    interceptor.clearThreadState(consumer)
+  }
+
+  @Test
+  fun `setupThreadState delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+
+    verify(delegate).setupThreadState(consumer)
+  }
+
+  @Test
+  fun `setupThreadState is no-op without delegate`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+
+    // should not throw
+    interceptor.setupThreadState(consumer)
+  }
+
+  @Test
+  fun `clearThreadState delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.clearThreadState(consumer)
+
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `clearThreadState delegates to existing interceptor even when sentry cleanup throws`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    whenever(lifecycleToken.close()).thenThrow(RuntimeException("boom"))
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    try {
+      interceptor.clearThreadState(consumer)
+    } catch (ignored: RuntimeException) {
+      // expected
+    }
+
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `full lifecycle intercept success clearThreadState closes token exactly once`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    whenever(delegate.intercept(record, consumer)).thenReturn(record)
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+    interceptor.intercept(record, consumer)
+    interceptor.success(record, consumer)
+    interceptor.clearThreadState(consumer)
+
+    // token closed once by success(); clearThreadState must not re-close it
+    verify(lifecycleToken, times(1)).close()
+    assertTrue(transaction.isFinished)
+    // delegate hooks still delegated across the full lifecycle
+    verify(delegate).setupThreadState(consumer)
+    verify(delegate).success(record, consumer)
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `when delegate intercept returns null clearThreadState still finishes transaction and closes token`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    // delegate filters the record — per Spring Kafka contract, success/failure will not be invoked
+    whenever(delegate.intercept(record, consumer)).thenReturn(null)
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+    val result = interceptor.intercept(record, consumer)
+    interceptor.clearThreadState(consumer)
+
+    assertNull(result)
+    verify(lifecycleToken, times(1)).close()
+    assertTrue(transaction.isFinished)
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `when delegate intercept throws clearThreadState still finishes transaction and closes token`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    val boom = RuntimeException("delegate boom")
+    whenever(delegate.intercept(record, consumer)).thenThrow(boom)
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+    val thrown = assertFailsWith<RuntimeException> { interceptor.intercept(record, consumer) }
+    assertEquals(boom, thrown)
+
+    interceptor.clearThreadState(consumer)
+
+    verify(lifecycleToken, times(1)).close()
+    assertTrue(transaction.isFinished)
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `intercept cleans up stale context from previous record`() {
+    val lifecycleToken2 = mock<ISentryLifecycleToken>()
+    val forkedScopes2 = mock<IScopes>()
+    whenever(forkedScopes2.options).thenReturn(options)
+    whenever(forkedScopes2.makeCurrent()).thenReturn(lifecycleToken2)
+    val tx2 = SentryTracer(TransactionContext("queue.process", "queue.process"), forkedScopes2)
+    whenever(forkedScopes2.startTransaction(any<TransactionContext>(), any())).thenReturn(tx2)
+
+    var callCount = 0
+
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    whenever(scopes.forkedRootScopes(any())).thenAnswer {
+      callCount++
+      if (callCount == 1) forkedScopes else forkedScopes2
+    }
+
+    // First intercept sets up context
+    interceptor.intercept(record, consumer)
+
+    // Second intercept without success/failure — should clean up stale context first
+    interceptor.intercept(record, consumer)
+
+    // First lifecycle token should have been closed by the defensive cleanup
+    verify(lifecycleToken).close()
+  }
+}
diff --git a/sentry-spring-boot-4/build.gradle.kts b/sentry-spring-boot-4/build.gradle.kts
index 69a40f7b64f..3b0b3be8630 100644
--- a/sentry-spring-boot-4/build.gradle.kts
+++ b/sentry-spring-boot-4/build.gradle.kts
@@ -36,6 +36,7 @@ dependencies {
   compileOnly(projects.sentryGraphql)
   compileOnly(projects.sentryGraphql22)
   compileOnly(projects.sentryQuartz)
+  compileOnly(libs.spring.kafka4)
   compileOnly(Config.Libs.springWeb)
   compileOnly(Config.Libs.springWebflux)
   compileOnly(libs.context.propagation)
@@ -68,6 +69,7 @@ dependencies {
   testImplementation(projects.sentryApacheHttpClient5)
   testImplementation(projects.sentryGraphql)
   testImplementation(projects.sentryGraphql22)
+  testImplementation(projects.sentryKafka)
   testImplementation(projects.sentryOpentelemetry.sentryOpentelemetryCore)
   testImplementation(projects.sentryOpentelemetry.sentryOpentelemetryAgent)
   testImplementation(projects.sentryOpentelemetry.sentryOpentelemetryAgentcustomization)
@@ -96,6 +98,7 @@ dependencies {
   testImplementation(libs.springboot4.starter)
   testImplementation(libs.springboot4.starter.aspectj)
   testImplementation(libs.springboot4.starter.graphql)
+  testImplementation(libs.spring.kafka4)
   testImplementation(libs.springboot4.starter.quartz)
   testImplementation(libs.springboot4.starter.security)
   testImplementation(libs.springboot4.starter.test)
diff --git a/sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryAutoConfiguration.java b/sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryAutoConfiguration.java
index ae9e3ac50fe..2429c1e7446 100644
--- a/sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryAutoConfiguration.java
+++ b/sentry-spring-boot-4/src/main/java/io/sentry/spring/boot4/SentryAutoConfiguration.java
@@ -31,6 +31,8 @@
 import io.sentry.spring7.checkin.SentryQuartzConfiguration;
 import io.sentry.spring7.exception.SentryCaptureExceptionParameterPointcutConfiguration;
 import io.sentry.spring7.exception.SentryExceptionParameterAdviceConfiguration;
+import io.sentry.spring7.kafka.SentryKafkaConsumerBeanPostProcessor;
+import io.sentry.spring7.kafka.SentryKafkaProducerBeanPostProcessor;
 import io.sentry.spring7.opentelemetry.SentryOpenTelemetryAgentWithoutAutoInitConfiguration;
 import io.sentry.spring7.opentelemetry.SentryOpenTelemetryNoAgentConfiguration;
 import io.sentry.spring7.tracing.CombinedTransactionNameProvider;
@@ -244,6 +246,34 @@ static class SentryCacheConfiguration {
       }
     }
 
+    @Configuration(proxyBeanMethods = false)
+    @ConditionalOnClass(
+        name = {
+          "org.springframework.kafka.core.KafkaTemplate",
+          "io.sentry.kafka.SentryKafkaProducer"
+        })
+    @ConditionalOnProperty(name = "sentry.enable-queue-tracing", havingValue = "true")
+    @ConditionalOnMissingClass({
+      "io.sentry.opentelemetry.SentryAutoConfigurationCustomizerProvider",
+      "io.sentry.opentelemetry.agent.AgentMarker"
+    })
+    @Open
+    static class SentryKafkaQueueConfiguration {
+
+      @Bean
+      public static @NotNull SentryKafkaProducerBeanPostProcessor
+          sentryKafkaProducerBeanPostProcessor() {
+        SentryIntegrationPackageStorage.getInstance().addIntegration("SpringKafka");
+        return new SentryKafkaProducerBeanPostProcessor();
+      }
+
+      @Bean
+      public static @NotNull SentryKafkaConsumerBeanPostProcessor
+          sentryKafkaConsumerBeanPostProcessor() {
+        return new SentryKafkaConsumerBeanPostProcessor();
+      }
+    }
+
     @Configuration(proxyBeanMethods = false)
     @ConditionalOnClass(ProceedingJoinPoint.class)
     @ConditionalOnProperty(
diff --git a/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryKafkaAutoConfigurationTest.kt b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryKafkaAutoConfigurationTest.kt
new file mode 100644
index 00000000000..d4d2b439427
--- /dev/null
+++ b/sentry-spring-boot-4/src/test/kotlin/io/sentry/spring/boot4/SentryKafkaAutoConfigurationTest.kt
@@ -0,0 +1,125 @@
+package io.sentry.spring.boot4
+
+import io.sentry.kafka.SentryKafkaProducer
+import io.sentry.opentelemetry.SentryAutoConfigurationCustomizerProvider
+import io.sentry.opentelemetry.agent.AgentMarker
+import io.sentry.spring7.kafka.SentryKafkaConsumerBeanPostProcessor
+import io.sentry.spring7.kafka.SentryKafkaProducerBeanPostProcessor
+import kotlin.test.Test
+import org.assertj.core.api.Assertions.assertThat
+import org.springframework.boot.autoconfigure.AutoConfigurations
+import org.springframework.boot.test.context.FilteredClassLoader
+import org.springframework.boot.test.context.runner.ApplicationContextRunner
+import org.springframework.kafka.core.KafkaTemplate
+
+class SentryKafkaAutoConfigurationTest {
+
+  private val contextRunner =
+    ApplicationContextRunner()
+      .withConfiguration(AutoConfigurations.of(SentryAutoConfiguration::class.java))
+      .withPropertyValues(
+        "sentry.dsn=http://key@localhost/proj",
+        "sentry.traces-sample-rate=1.0",
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false",
+        "sentry.debug=false",
+      )
+
+  private val noOtelClassLoader =
+    FilteredClassLoader(
+      SentryAutoConfigurationCustomizerProvider::class.java,
+      AgentMarker::class.java,
+    )
+
+  private val noOtelCustomizerClassLoader =
+    FilteredClassLoader(SentryAutoConfigurationCustomizerProvider::class.java)
+
+  private val noSentryKafkaClassLoader =
+    FilteredClassLoader(
+      SentryKafkaProducer::class.java,
+      SentryAutoConfigurationCustomizerProvider::class.java,
+      AgentMarker::class.java,
+    )
+
+  private val noSpringKafkaClassLoader =
+    FilteredClassLoader(
+      KafkaTemplate::class.java,
+      SentryAutoConfigurationCustomizerProvider::class.java,
+      AgentMarker::class.java,
+    )
+
+  @Test
+  fun `registers Kafka BPPs when queue tracing is enabled`() {
+    contextRunner
+      .withClassLoader(noOtelClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).hasSingleBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).hasSingleBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when queue tracing is disabled`() {
+    contextRunner.withClassLoader(noOtelClassLoader).run { context ->
+      assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+      assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+    }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when sentry-kafka is not present`() {
+    contextRunner
+      .withClassLoader(noSentryKafkaClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when spring-kafka is not present`() {
+    contextRunner
+      .withClassLoader(noSpringKafkaClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when queue tracing is explicitly false`() {
+    contextRunner
+      .withClassLoader(noOtelClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=false")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when OpenTelemetry agent is present`() {
+    contextRunner
+      .withClassLoader(noOtelCustomizerClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when OpenTelemetry integration is present`() {
+    contextRunner.withPropertyValues("sentry.enable-queue-tracing=true").run { context ->
+      assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+      assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+    }
+  }
+}
diff --git a/sentry-spring-boot-jakarta/build.gradle.kts b/sentry-spring-boot-jakarta/build.gradle.kts
index 04166519240..36b7dad3cc6 100644
--- a/sentry-spring-boot-jakarta/build.gradle.kts
+++ b/sentry-spring-boot-jakarta/build.gradle.kts
@@ -40,6 +40,7 @@ dependencies {
   compileOnly(projects.sentryGraphql)
   compileOnly(projects.sentryGraphql22)
   compileOnly(projects.sentryQuartz)
+  compileOnly(libs.spring.kafka3)
   compileOnly(Config.Libs.springWeb)
   compileOnly(Config.Libs.springWebflux)
   compileOnly(libs.context.propagation)
@@ -70,6 +71,7 @@ dependencies {
   testImplementation(projects.sentryApacheHttpClient5)
   testImplementation(projects.sentryGraphql)
   testImplementation(projects.sentryGraphql22)
+  testImplementation(projects.sentryKafka)
   testImplementation(projects.sentryOpentelemetry.sentryOpentelemetryCore)
   testImplementation(projects.sentryOpentelemetry.sentryOpentelemetryAgent)
   testImplementation(projects.sentryOpentelemetry.sentryOpentelemetryAgentcustomization)
@@ -90,6 +92,7 @@ dependencies {
   testImplementation(libs.springboot3.starter)
   testImplementation(libs.springboot3.starter.aop)
   testImplementation(libs.springboot3.starter.graphql)
+  testImplementation(libs.spring.kafka3)
   testImplementation(libs.springboot3.starter.quartz)
   testImplementation(libs.springboot3.starter.security)
   testImplementation(libs.springboot3.starter.test)
diff --git a/sentry-spring-boot-jakarta/src/main/java/io/sentry/spring/boot/jakarta/SentryAutoConfiguration.java b/sentry-spring-boot-jakarta/src/main/java/io/sentry/spring/boot/jakarta/SentryAutoConfiguration.java
index ef57868ad87..e1f8b026274 100644
--- a/sentry-spring-boot-jakarta/src/main/java/io/sentry/spring/boot/jakarta/SentryAutoConfiguration.java
+++ b/sentry-spring-boot-jakarta/src/main/java/io/sentry/spring/boot/jakarta/SentryAutoConfiguration.java
@@ -31,6 +31,8 @@
 import io.sentry.spring.jakarta.checkin.SentryQuartzConfiguration;
 import io.sentry.spring.jakarta.exception.SentryCaptureExceptionParameterPointcutConfiguration;
 import io.sentry.spring.jakarta.exception.SentryExceptionParameterAdviceConfiguration;
+import io.sentry.spring.jakarta.kafka.SentryKafkaConsumerBeanPostProcessor;
+import io.sentry.spring.jakarta.kafka.SentryKafkaProducerBeanPostProcessor;
 import io.sentry.spring.jakarta.opentelemetry.SentryOpenTelemetryAgentWithoutAutoInitConfiguration;
 import io.sentry.spring.jakarta.opentelemetry.SentryOpenTelemetryNoAgentConfiguration;
 import io.sentry.spring.jakarta.tracing.CombinedTransactionNameProvider;
@@ -246,6 +248,34 @@ static class SentryCacheConfiguration {
       }
     }
 
+    @Configuration(proxyBeanMethods = false)
+    @ConditionalOnClass(
+        name = {
+          "org.springframework.kafka.core.KafkaTemplate",
+          "io.sentry.kafka.SentryKafkaProducer"
+        })
+    @ConditionalOnProperty(name = "sentry.enable-queue-tracing", havingValue = "true")
+    @ConditionalOnMissingClass({
+      "io.sentry.opentelemetry.SentryAutoConfigurationCustomizerProvider",
+      "io.sentry.opentelemetry.agent.AgentMarker"
+    })
+    @Open
+    static class SentryKafkaQueueConfiguration {
+
+      @Bean
+      public static @NotNull SentryKafkaProducerBeanPostProcessor
+          sentryKafkaProducerBeanPostProcessor() {
+        SentryIntegrationPackageStorage.getInstance().addIntegration("SpringKafka");
+        return new SentryKafkaProducerBeanPostProcessor();
+      }
+
+      @Bean
+      public static @NotNull SentryKafkaConsumerBeanPostProcessor
+          sentryKafkaConsumerBeanPostProcessor() {
+        return new SentryKafkaConsumerBeanPostProcessor();
+      }
+    }
+
     @Configuration(proxyBeanMethods = false)
     @ConditionalOnClass(ProceedingJoinPoint.class)
     @ConditionalOnProperty(
diff --git a/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryKafkaAutoConfigurationTest.kt b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryKafkaAutoConfigurationTest.kt
new file mode 100644
index 00000000000..392e5184759
--- /dev/null
+++ b/sentry-spring-boot-jakarta/src/test/kotlin/io/sentry/spring/boot/jakarta/SentryKafkaAutoConfigurationTest.kt
@@ -0,0 +1,125 @@
+package io.sentry.spring.boot.jakarta
+
+import io.sentry.kafka.SentryKafkaProducer
+import io.sentry.opentelemetry.SentryAutoConfigurationCustomizerProvider
+import io.sentry.opentelemetry.agent.AgentMarker
+import io.sentry.spring.jakarta.kafka.SentryKafkaConsumerBeanPostProcessor
+import io.sentry.spring.jakarta.kafka.SentryKafkaProducerBeanPostProcessor
+import kotlin.test.Test
+import org.assertj.core.api.Assertions.assertThat
+import org.springframework.boot.autoconfigure.AutoConfigurations
+import org.springframework.boot.test.context.FilteredClassLoader
+import org.springframework.boot.test.context.runner.ApplicationContextRunner
+import org.springframework.kafka.core.KafkaTemplate
+
+class SentryKafkaAutoConfigurationTest {
+
+  private val contextRunner =
+    ApplicationContextRunner()
+      .withConfiguration(AutoConfigurations.of(SentryAutoConfiguration::class.java))
+      .withPropertyValues(
+        "sentry.dsn=http://key@localhost/proj",
+        "sentry.traces-sample-rate=1.0",
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false",
+        "sentry.debug=false",
+      )
+
+  private val noOtelClassLoader =
+    FilteredClassLoader(
+      SentryAutoConfigurationCustomizerProvider::class.java,
+      AgentMarker::class.java,
+    )
+
+  private val noOtelCustomizerClassLoader =
+    FilteredClassLoader(SentryAutoConfigurationCustomizerProvider::class.java)
+
+  private val noSentryKafkaClassLoader =
+    FilteredClassLoader(
+      SentryKafkaProducer::class.java,
+      SentryAutoConfigurationCustomizerProvider::class.java,
+      AgentMarker::class.java,
+    )
+
+  private val noSpringKafkaClassLoader =
+    FilteredClassLoader(
+      KafkaTemplate::class.java,
+      SentryAutoConfigurationCustomizerProvider::class.java,
+      AgentMarker::class.java,
+    )
+
+  @Test
+  fun `registers Kafka BPPs when queue tracing is enabled`() {
+    contextRunner
+      .withClassLoader(noOtelClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).hasSingleBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).hasSingleBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when queue tracing is disabled`() {
+    contextRunner.withClassLoader(noOtelClassLoader).run { context ->
+      assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+      assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+    }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when sentry-kafka is not present`() {
+    contextRunner
+      .withClassLoader(noSentryKafkaClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when spring-kafka is not present`() {
+    contextRunner
+      .withClassLoader(noSpringKafkaClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when queue tracing is explicitly false`() {
+    contextRunner
+      .withClassLoader(noOtelClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=false")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when OpenTelemetry agent is present`() {
+    contextRunner
+      .withClassLoader(noOtelCustomizerClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when OpenTelemetry integration is present`() {
+    contextRunner.withPropertyValues("sentry.enable-queue-tracing=true").run { context ->
+      assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+      assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+    }
+  }
+}
diff --git a/sentry-spring-boot/build.gradle.kts b/sentry-spring-boot/build.gradle.kts
index 43150869db5..74f5d7c87bb 100644
--- a/sentry-spring-boot/build.gradle.kts
+++ b/sentry-spring-boot/build.gradle.kts
@@ -38,11 +38,13 @@ dependencies {
   compileOnly(libs.springboot.starter.graphql)
   compileOnly(libs.springboot.starter.quartz)
   compileOnly(libs.springboot.starter.security)
+  compileOnly(libs.spring.kafka2)
   compileOnly(platform(libs.springboot2.bom))
   compileOnly(Config.Libs.springWeb)
   compileOnly(Config.Libs.springWebflux)
   compileOnly(projects.sentryOpentelemetry.sentryOpentelemetryCore)
   compileOnly(projects.sentryGraphql)
+  compileOnly(projects.sentryKafka)
   compileOnly(projects.sentryQuartz)
 
   annotationProcessor(platform(libs.springboot2.bom))
@@ -57,6 +59,7 @@ dependencies {
   testImplementation(projects.sentryLogback)
   testImplementation(projects.sentryQuartz)
   testImplementation(projects.sentryApacheHttpClient5)
+  testImplementation(projects.sentryKafka)
   testImplementation(projects.sentryTestSupport)
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(libs.kotlin.test.junit)
@@ -69,6 +72,7 @@ dependencies {
   testImplementation(libs.springboot.starter.aop)
   testImplementation(libs.springboot.starter.quartz)
   testImplementation(libs.springboot.starter.security)
+  testImplementation(libs.spring.kafka2)
   testImplementation(libs.springboot.starter.test)
   testImplementation(libs.springboot.starter.web)
   testImplementation(libs.springboot.starter.webflux)
diff --git a/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java b/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java
index 99fd602f74b..c7d5a892e9f 100644
--- a/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java
+++ b/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java
@@ -31,6 +31,8 @@
 import io.sentry.spring.checkin.SentryQuartzConfiguration;
 import io.sentry.spring.exception.SentryCaptureExceptionParameterPointcutConfiguration;
 import io.sentry.spring.exception.SentryExceptionParameterAdviceConfiguration;
+import io.sentry.spring.kafka.SentryKafkaConsumerBeanPostProcessor;
+import io.sentry.spring.kafka.SentryKafkaProducerBeanPostProcessor;
 import io.sentry.spring.opentelemetry.SentryOpenTelemetryAgentWithoutAutoInitConfiguration;
 import io.sentry.spring.opentelemetry.SentryOpenTelemetryNoAgentConfiguration;
 import io.sentry.spring.tracing.CombinedTransactionNameProvider;
@@ -231,6 +233,34 @@ static class SentryCacheConfiguration {
       }
     }
 
+    @Configuration(proxyBeanMethods = false)
+    @ConditionalOnClass(
+        name = {
+          "org.springframework.kafka.core.KafkaTemplate",
+          "io.sentry.kafka.SentryKafkaProducer"
+        })
+    @ConditionalOnProperty(name = "sentry.enable-queue-tracing", havingValue = "true")
+    @ConditionalOnMissingClass({
+      "io.sentry.opentelemetry.SentryAutoConfigurationCustomizerProvider",
+      "io.sentry.opentelemetry.agent.AgentMarker"
+    })
+    @Open
+    static class SentryKafkaQueueConfiguration {
+
+      @Bean
+      public static @NotNull SentryKafkaProducerBeanPostProcessor
+          sentryKafkaProducerBeanPostProcessor() {
+        SentryIntegrationPackageStorage.getInstance().addIntegration("SpringKafka");
+        return new SentryKafkaProducerBeanPostProcessor();
+      }
+
+      @Bean
+      public static @NotNull SentryKafkaConsumerBeanPostProcessor
+          sentryKafkaConsumerBeanPostProcessor() {
+        return new SentryKafkaConsumerBeanPostProcessor();
+      }
+    }
+
     @Configuration(proxyBeanMethods = false)
     @ConditionalOnClass(ProceedingJoinPoint.class)
     @ConditionalOnProperty(
diff --git a/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryKafkaAutoConfigurationTest.kt b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryKafkaAutoConfigurationTest.kt
new file mode 100644
index 00000000000..fdf12bacf00
--- /dev/null
+++ b/sentry-spring-boot/src/test/kotlin/io/sentry/spring/boot/SentryKafkaAutoConfigurationTest.kt
@@ -0,0 +1,125 @@
+package io.sentry.spring.boot
+
+import io.sentry.kafka.SentryKafkaProducer
+import io.sentry.opentelemetry.SentryAutoConfigurationCustomizerProvider
+import io.sentry.opentelemetry.agent.AgentMarker
+import io.sentry.spring.kafka.SentryKafkaConsumerBeanPostProcessor
+import io.sentry.spring.kafka.SentryKafkaProducerBeanPostProcessor
+import kotlin.test.Test
+import org.assertj.core.api.Assertions.assertThat
+import org.springframework.boot.autoconfigure.AutoConfigurations
+import org.springframework.boot.test.context.FilteredClassLoader
+import org.springframework.boot.test.context.runner.ApplicationContextRunner
+import org.springframework.kafka.core.KafkaTemplate
+
+class SentryKafkaAutoConfigurationTest {
+
+  private val contextRunner =
+    ApplicationContextRunner()
+      .withConfiguration(AutoConfigurations.of(SentryAutoConfiguration::class.java))
+      .withPropertyValues(
+        "sentry.dsn=http://key@localhost/proj",
+        "sentry.traces-sample-rate=1.0",
+        "sentry.shutdownTimeoutMillis=0",
+        "sentry.sessionFlushTimeoutMillis=0",
+        "sentry.flushTimeoutMillis=0",
+        "sentry.readTimeoutMillis=50",
+        "sentry.connectionTimeoutMillis=50",
+        "sentry.send-modules=false",
+        "sentry.debug=false",
+      )
+
+  private val noOtelClassLoader =
+    FilteredClassLoader(
+      SentryAutoConfigurationCustomizerProvider::class.java,
+      AgentMarker::class.java,
+    )
+
+  private val noOtelCustomizerClassLoader =
+    FilteredClassLoader(SentryAutoConfigurationCustomizerProvider::class.java)
+
+  private val noSentryKafkaClassLoader =
+    FilteredClassLoader(
+      SentryKafkaProducer::class.java,
+      SentryAutoConfigurationCustomizerProvider::class.java,
+      AgentMarker::class.java,
+    )
+
+  private val noSpringKafkaClassLoader =
+    FilteredClassLoader(
+      KafkaTemplate::class.java,
+      SentryAutoConfigurationCustomizerProvider::class.java,
+      AgentMarker::class.java,
+    )
+
+  @Test
+  fun `registers Kafka BPPs when queue tracing is enabled`() {
+    contextRunner
+      .withClassLoader(noOtelClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).hasSingleBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).hasSingleBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when queue tracing is disabled`() {
+    contextRunner.withClassLoader(noOtelClassLoader).run { context ->
+      assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+      assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+    }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when sentry-kafka is not present`() {
+    contextRunner
+      .withClassLoader(noSentryKafkaClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when spring-kafka is not present`() {
+    contextRunner
+      .withClassLoader(noSpringKafkaClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when queue tracing is explicitly false`() {
+    contextRunner
+      .withClassLoader(noOtelClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=false")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when OpenTelemetry agent is present`() {
+    contextRunner
+      .withClassLoader(noOtelCustomizerClassLoader)
+      .withPropertyValues("sentry.enable-queue-tracing=true")
+      .run { context ->
+        assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+        assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+      }
+  }
+
+  @Test
+  fun `does not register Kafka BPPs when OpenTelemetry integration is present`() {
+    contextRunner.withPropertyValues("sentry.enable-queue-tracing=true").run { context ->
+      assertThat(context).doesNotHaveBean(SentryKafkaProducerBeanPostProcessor::class.java)
+      assertThat(context).doesNotHaveBean(SentryKafkaConsumerBeanPostProcessor::class.java)
+    }
+  }
+}
diff --git a/sentry-spring-jakarta/api/sentry-spring-jakarta.api b/sentry-spring-jakarta/api/sentry-spring-jakarta.api
index fe634da6f4c..24b9af7e14b 100644
--- a/sentry-spring-jakarta/api/sentry-spring-jakarta.api
+++ b/sentry-spring-jakarta/api/sentry-spring-jakarta.api
@@ -244,6 +244,29 @@ public final class io/sentry/spring/jakarta/graphql/SentrySpringSubscriptionHand
 	public fun onSubscriptionResult (Ljava/lang/Object;Lio/sentry/IScopes;Lio/sentry/graphql/ExceptionReporter;Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;)Ljava/lang/Object;
 }
 
+public final class io/sentry/spring/jakarta/kafka/SentryKafkaConsumerBeanPostProcessor : org/springframework/beans/factory/config/BeanPostProcessor, org/springframework/core/PriorityOrdered {
+	public fun <init> ()V
+	public fun getOrder ()I
+	public fun postProcessAfterInitialization (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class io/sentry/spring/jakarta/kafka/SentryKafkaProducerBeanPostProcessor : org/springframework/beans/factory/config/BeanPostProcessor, org/springframework/core/PriorityOrdered {
+	public fun <init> ()V
+	public fun getOrder ()I
+	public fun postProcessAfterInitialization (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class io/sentry/spring/jakarta/kafka/SentryKafkaRecordInterceptor : org/springframework/kafka/listener/RecordInterceptor {
+	public fun <init> (Lio/sentry/IScopes;)V
+	public fun <init> (Lio/sentry/IScopes;Lorg/springframework/kafka/listener/RecordInterceptor;)V
+	public fun afterRecord (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun clearThreadState (Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun failure (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Ljava/lang/Exception;Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun intercept (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Lorg/apache/kafka/clients/consumer/Consumer;)Lorg/apache/kafka/clients/consumer/ConsumerRecord;
+	public fun setupThreadState (Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun success (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Lorg/apache/kafka/clients/consumer/Consumer;)V
+}
+
 public class io/sentry/spring/jakarta/opentelemetry/SentryOpenTelemetryAgentWithoutAutoInitConfiguration {
 	public fun <init> ()V
 	public fun sentryOpenTelemetryOptionsConfiguration ()Lio/sentry/Sentry$OptionsConfiguration;
diff --git a/sentry-spring-jakarta/build.gradle.kts b/sentry-spring-jakarta/build.gradle.kts
index f1920e24510..cbf2e5346b5 100644
--- a/sentry-spring-jakarta/build.gradle.kts
+++ b/sentry-spring-jakarta/build.gradle.kts
@@ -29,6 +29,7 @@ tasks.withType<KotlinCompile>().configureEach {
 
 dependencies {
   api(projects.sentry)
+  compileOnly(projects.sentryKafka)
   compileOnly(platform(SpringBootPlugin.BOM_COORDINATES))
   compileOnly(Config.Libs.springWeb)
   compileOnly(Config.Libs.springAop)
@@ -41,6 +42,7 @@ dependencies {
   compileOnly(libs.servlet.jakarta.api)
   compileOnly(libs.slf4j.api)
   compileOnly(libs.springboot3.starter.graphql)
+  compileOnly(libs.spring.kafka3)
   compileOnly(libs.springboot3.starter.quartz)
 
   compileOnly(Config.Libs.springWebflux)
@@ -58,6 +60,7 @@ dependencies {
   // tests
   testImplementation(projects.sentryTestSupport)
   testImplementation(projects.sentryGraphql)
+  testImplementation(projects.sentryKafka)
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(libs.awaitility.kotlin)
   testImplementation(libs.context.propagation)
@@ -68,6 +71,7 @@ dependencies {
   testImplementation(libs.springboot3.starter.aop)
   testImplementation(libs.springboot3.starter.graphql)
   testImplementation(libs.springboot3.starter.security)
+  testImplementation(libs.spring.kafka3)
   testImplementation(libs.springboot3.starter.test)
   testImplementation(libs.springboot3.starter.web)
   testImplementation(libs.springboot3.starter.webflux)
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaConsumerBeanPostProcessor.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaConsumerBeanPostProcessor.java
new file mode 100644
index 00000000000..e4676b79cfd
--- /dev/null
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaConsumerBeanPostProcessor.java
@@ -0,0 +1,98 @@
+package io.sentry.spring.jakarta.kafka;
+
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryLevel;
+import java.lang.reflect.Field;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.core.Ordered;
+import org.springframework.core.PriorityOrdered;
+import org.springframework.kafka.config.AbstractKafkaListenerContainerFactory;
+import org.springframework.kafka.listener.RecordInterceptor;
+
+/**
+ * Registers {@link SentryKafkaRecordInterceptor} on {@link AbstractKafkaListenerContainerFactory}
+ * beans. If an existing {@link RecordInterceptor} is already set, it is composed as a delegate.
+ */
+@ApiStatus.Internal
+public final class SentryKafkaConsumerBeanPostProcessor
+    implements BeanPostProcessor, PriorityOrdered {
+
+  private static final @NotNull String RECORD_INTERCEPTOR_FIELD_NAME = "recordInterceptor";
+
+  private final @NotNull String recordInterceptorFieldName;
+
+  public SentryKafkaConsumerBeanPostProcessor() {
+    this(RECORD_INTERCEPTOR_FIELD_NAME);
+  }
+
+  SentryKafkaConsumerBeanPostProcessor(final @NotNull String recordInterceptorFieldName) {
+    this.recordInterceptorFieldName = recordInterceptorFieldName;
+  }
+
+  private static final class InterceptorReadFailedException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    InterceptorReadFailedException(final @NotNull Throwable cause) {
+      super(cause);
+    }
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public @NotNull Object postProcessAfterInitialization(
+      final @NotNull Object bean, final @NotNull String beanName) throws BeansException {
+    if (bean instanceof AbstractKafkaListenerContainerFactory) {
+      final @NotNull AbstractKafkaListenerContainerFactory<?, ?, ?> factory =
+          (AbstractKafkaListenerContainerFactory<?, ?, ?>) bean;
+
+      final @Nullable RecordInterceptor<?, ?> existing;
+      try {
+        existing = getExistingInterceptor(factory);
+      } catch (InterceptorReadFailedException e) {
+        ScopesAdapter.getInstance()
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.ERROR,
+                e,
+                "Sentry Kafka consumer tracing disabled for factory '%s' \u2014 could not read "
+                    + "existing recordInterceptor via reflection. Refusing to install Sentry's "
+                    + "interceptor to avoid overwriting a customer-configured RecordInterceptor.",
+                beanName);
+        return bean;
+      }
+
+      if (existing instanceof SentryKafkaRecordInterceptor) {
+        return bean;
+      }
+
+      @SuppressWarnings("rawtypes")
+      final RecordInterceptor sentryInterceptor =
+          new SentryKafkaRecordInterceptor<>(ScopesAdapter.getInstance(), existing);
+      factory.setRecordInterceptor(sentryInterceptor);
+    }
+    return bean;
+  }
+
+  private @Nullable RecordInterceptor<?, ?> getExistingInterceptor(
+      final @NotNull AbstractKafkaListenerContainerFactory<?, ?, ?> factory)
+      throws InterceptorReadFailedException {
+    try {
+      final @NotNull Field field =
+          AbstractKafkaListenerContainerFactory.class.getDeclaredField(recordInterceptorFieldName);
+      field.setAccessible(true);
+      return (RecordInterceptor<?, ?>) field.get(factory);
+    } catch (NoSuchFieldException | IllegalAccessException | RuntimeException e) {
+      throw new InterceptorReadFailedException(e);
+    }
+  }
+
+  @Override
+  public int getOrder() {
+    return Ordered.LOWEST_PRECEDENCE;
+  }
+}
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaProducerBeanPostProcessor.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaProducerBeanPostProcessor.java
new file mode 100644
index 00000000000..8a06e4e338e
--- /dev/null
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaProducerBeanPostProcessor.java
@@ -0,0 +1,76 @@
+package io.sentry.spring.jakarta.kafka;
+
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryLevel;
+import io.sentry.kafka.SentryKafkaProducer;
+import org.apache.kafka.clients.producer.Producer;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.core.Ordered;
+import org.springframework.core.PriorityOrdered;
+import org.springframework.kafka.core.ProducerFactory;
+import org.springframework.kafka.core.ProducerPostProcessor;
+
+/**
+ * Installs a {@link ProducerPostProcessor} on every {@link ProducerFactory} bean so that each
+ * {@link Producer} created by Spring Kafka is wrapped via {@link SentryKafkaProducer#wrap
+ * SentryKafkaProducer.wrap(Producer)}.
+ *
+ * <p>The wrapper records a {@code queue.publish} span around each {@code send(...)} that finishes
+ * when the broker ack callback fires, giving a real producer-send lifecycle span. {@code
+ * KafkaTemplate} beans are left untouched, so all customer-configured listeners, interceptors and
+ * observation settings are preserved.
+ *
+ * <p>Note: {@link ProducerFactory#addPostProcessor(ProducerPostProcessor)} is a default method on
+ * the interface that is a no-op unless overridden. Custom factories that do not extend {@code
+ * DefaultKafkaProducerFactory} will not receive Sentry producer instrumentation; a warning is
+ * logged at startup in that case.
+ */
+@ApiStatus.Internal
+public final class SentryKafkaProducerBeanPostProcessor
+    implements BeanPostProcessor, PriorityOrdered {
+
+  @Override
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public @NotNull Object postProcessAfterInitialization(
+      final @NotNull Object bean, final @NotNull String beanName) throws BeansException {
+    if (bean instanceof ProducerFactory) {
+      final @NotNull ProducerFactory factory = (ProducerFactory) bean;
+      final @NotNull SentryProducerPostProcessor pp = new SentryProducerPostProcessor<>();
+      factory.addPostProcessor(pp);
+      if (!factory.getPostProcessors().contains(pp)) {
+        ScopesAdapter.getInstance()
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.WARNING,
+                "Sentry Kafka producer tracing not active for ProducerFactory '%s' (%s). "
+                    + "addPostProcessor() was not honored — the factory may not extend "
+                    + "DefaultKafkaProducerFactory. Wrap producers manually with "
+                    + "SentryKafkaProducer.wrap(producer).",
+                beanName,
+                factory.getClass().getName());
+      }
+    }
+    return bean;
+  }
+
+  @Override
+  public int getOrder() {
+    return Ordered.LOWEST_PRECEDENCE;
+  }
+
+  /**
+   * Marker {@link ProducerPostProcessor} that wraps the freshly created Kafka {@link Producer} via
+   * {@link SentryKafkaProducer#wrap}.
+   */
+  static final class SentryProducerPostProcessor<K, V> implements ProducerPostProcessor<K, V> {
+    @Override
+    public @NotNull Producer<K, V> apply(final @NotNull Producer<K, V> producer) {
+      return SentryKafkaProducer.wrap(
+          producer, ScopesAdapter.getInstance(), "auto.queue.spring_jakarta.kafka.producer");
+    }
+  }
+}
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaRecordInterceptor.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaRecordInterceptor.java
new file mode 100644
index 00000000000..72535712695
--- /dev/null
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/kafka/SentryKafkaRecordInterceptor.java
@@ -0,0 +1,292 @@
+package io.sentry.spring.jakarta.kafka;
+
+import io.sentry.BaggageHeader;
+import io.sentry.DateUtils;
+import io.sentry.IScopes;
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.ITransaction;
+import io.sentry.SentryLevel;
+import io.sentry.SentryTraceHeader;
+import io.sentry.SpanDataConvention;
+import io.sentry.SpanStatus;
+import io.sentry.TransactionContext;
+import io.sentry.TransactionOptions;
+import io.sentry.kafka.SentryKafkaProducer;
+import io.sentry.util.SpanUtils;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.common.header.Header;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.kafka.listener.RecordInterceptor;
+import org.springframework.kafka.support.KafkaHeaders;
+
+/**
+ * A {@link RecordInterceptor} that creates {@code queue.process} transactions for incoming Kafka
+ * records with distributed tracing support.
+ */
+@ApiStatus.Internal
+public final class SentryKafkaRecordInterceptor<K, V> implements RecordInterceptor<K, V> {
+
+  static final String TRACE_ORIGIN = "auto.queue.spring_jakarta.kafka.consumer";
+
+  private final @NotNull IScopes scopes;
+  private final @Nullable RecordInterceptor<K, V> delegate;
+
+  private static final @NotNull ThreadLocal<SentryRecordContext> currentContext =
+      new ThreadLocal<>();
+
+  public SentryKafkaRecordInterceptor(final @NotNull IScopes scopes) {
+    this(scopes, null);
+  }
+
+  public SentryKafkaRecordInterceptor(
+      final @NotNull IScopes scopes, final @Nullable RecordInterceptor<K, V> delegate) {
+    this.scopes = scopes;
+    this.delegate = delegate;
+  }
+
+  @Override
+  public @Nullable ConsumerRecord<K, V> intercept(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    if (!scopes.getOptions().isEnableQueueTracing() || isIgnored()) {
+      return delegateIntercept(record, consumer);
+    }
+
+    try {
+      finishStaleContext();
+
+      final @NotNull IScopes forkedScopes = scopes.forkedRootScopes("SentryKafkaRecordInterceptor");
+      final @NotNull ISentryLifecycleToken lifecycleToken = forkedScopes.makeCurrent();
+      currentContext.set(new SentryRecordContext(lifecycleToken, null));
+
+      final @Nullable TransactionContext transactionContext = continueTrace(forkedScopes, record);
+
+      final @Nullable ITransaction transaction =
+          startTransaction(forkedScopes, record, transactionContext);
+      currentContext.set(new SentryRecordContext(lifecycleToken, transaction));
+    } catch (Throwable t) {
+      scopes.getOptions().getLogger().log(SentryLevel.ERROR, "Unable to wrap Kafka consumer.", t);
+    }
+    return delegateIntercept(record, consumer);
+  }
+
+  @Override
+  public void success(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    try {
+      if (delegate != null) {
+        delegate.success(record, consumer);
+      }
+    } finally {
+      finishSpan(SpanStatus.OK, null);
+    }
+  }
+
+  @Override
+  public void failure(
+      final @NotNull ConsumerRecord<K, V> record,
+      final @NotNull Exception exception,
+      final @NotNull Consumer<K, V> consumer) {
+    try {
+      if (delegate != null) {
+        delegate.failure(record, exception, consumer);
+      }
+    } finally {
+      finishSpan(SpanStatus.INTERNAL_ERROR, exception);
+    }
+  }
+
+  @Override
+  public void afterRecord(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    if (delegate != null) {
+      delegate.afterRecord(record, consumer);
+    }
+  }
+
+  @Override
+  public void setupThreadState(final @NotNull Consumer<?, ?> consumer) {
+    if (delegate != null) {
+      delegate.setupThreadState(consumer);
+    }
+  }
+
+  @Override
+  public void clearThreadState(final @NotNull Consumer<?, ?> consumer) {
+    try {
+      finishStaleContext();
+    } finally {
+      if (delegate != null) {
+        delegate.clearThreadState(consumer);
+      }
+    }
+  }
+
+  private boolean isIgnored() {
+    return SpanUtils.isIgnored(scopes.getOptions().getIgnoredSpanOrigins(), TRACE_ORIGIN);
+  }
+
+  private @Nullable ConsumerRecord<K, V> delegateIntercept(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    if (delegate != null) {
+      return delegate.intercept(record, consumer);
+    }
+    return record;
+  }
+
+  private @Nullable TransactionContext continueTrace(
+      final @NotNull IScopes forkedScopes, final @NotNull ConsumerRecord<K, V> record) {
+    final @Nullable String sentryTrace = headerValue(record, SentryTraceHeader.SENTRY_TRACE_HEADER);
+    final @Nullable List<String> baggageHeaders =
+        headerValues(record, BaggageHeader.BAGGAGE_HEADER);
+    return forkedScopes.continueTrace(sentryTrace, baggageHeaders);
+  }
+
+  private @Nullable ITransaction startTransaction(
+      final @NotNull IScopes forkedScopes,
+      final @NotNull ConsumerRecord<K, V> record,
+      final @Nullable TransactionContext transactionContext) {
+    if (!forkedScopes.getOptions().isTracingEnabled()) {
+      return null;
+    }
+
+    final @NotNull TransactionContext txContext =
+        transactionContext != null
+            ? transactionContext
+            : new TransactionContext(record.topic(), "queue.process");
+    txContext.setName(record.topic());
+    txContext.setOperation("queue.process");
+
+    final @NotNull TransactionOptions txOptions = new TransactionOptions();
+    txOptions.setOrigin(TRACE_ORIGIN);
+    txOptions.setBindToScope(true);
+
+    final @NotNull ITransaction transaction = forkedScopes.startTransaction(txContext, txOptions);
+
+    if (transaction.isNoOp()) {
+      return null;
+    }
+
+    transaction.setData(SpanDataConvention.MESSAGING_SYSTEM, "kafka");
+    transaction.setData(SpanDataConvention.MESSAGING_DESTINATION_NAME, record.topic());
+
+    final @Nullable String messageId = headerValue(record, "messaging.message.id");
+    if (messageId != null) {
+      transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_ID, messageId);
+    }
+
+    final int bodySize = record.serializedValueSize();
+    if (bodySize >= 0) {
+      transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE, bodySize);
+    }
+
+    final @Nullable Integer retryCount = retryCount(record);
+    if (retryCount != null) {
+      transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT, retryCount);
+    }
+
+    final @Nullable String enqueuedTimeStr =
+        headerValue(record, SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER);
+    if (enqueuedTimeStr != null) {
+      try {
+        final double enqueuedTimeSeconds = Double.parseDouble(enqueuedTimeStr);
+        final double nowSeconds = DateUtils.millisToSeconds(System.currentTimeMillis());
+        final long latencyMs = (long) ((nowSeconds - enqueuedTimeSeconds) * 1000);
+        if (latencyMs >= 0) {
+          transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_RECEIVE_LATENCY, latencyMs);
+        }
+      } catch (NumberFormatException ignored) {
+        // ignore malformed header
+      }
+    }
+
+    return transaction;
+  }
+
+  private @Nullable Integer retryCount(final @NotNull ConsumerRecord<K, V> record) {
+    final @Nullable Header header = record.headers().lastHeader(KafkaHeaders.DELIVERY_ATTEMPT);
+    if (header == null) {
+      return null;
+    }
+
+    final byte[] value = header.value();
+    if (value == null || value.length != Integer.BYTES) {
+      return null;
+    }
+
+    final int attempt = ByteBuffer.wrap(value).getInt();
+    if (attempt <= 0) {
+      return null;
+    }
+
+    return attempt - 1;
+  }
+
+  private void finishStaleContext() {
+    if (currentContext.get() != null) {
+      finishSpan(SpanStatus.UNKNOWN, null);
+    }
+  }
+
+  private void finishSpan(final @NotNull SpanStatus status, final @Nullable Throwable throwable) {
+    final @Nullable SentryRecordContext ctx = currentContext.get();
+    if (ctx == null) {
+      return;
+    }
+    currentContext.remove();
+
+    try {
+      final @Nullable ITransaction transaction = ctx.transaction;
+      if (transaction != null) {
+        transaction.setStatus(status);
+        if (throwable != null) {
+          transaction.setThrowable(throwable);
+        }
+        transaction.finish();
+      }
+    } finally {
+      ctx.lifecycleToken.close();
+    }
+  }
+
+  private @Nullable String headerValue(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull String headerName) {
+    final @Nullable Header header = record.headers().lastHeader(headerName);
+    if (header == null || header.value() == null) {
+      return null;
+    }
+    return new String(header.value(), StandardCharsets.UTF_8);
+  }
+
+  private @Nullable List<String> headerValues(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull String headerName) {
+    @Nullable List<String> values = null;
+    for (final @NotNull Header header : record.headers().headers(headerName)) {
+      if (header.value() != null) {
+        if (values == null) {
+          values = new ArrayList<>();
+        }
+        values.add(new String(header.value(), StandardCharsets.UTF_8));
+      }
+    }
+    return values;
+  }
+
+  private static final class SentryRecordContext {
+    final @NotNull ISentryLifecycleToken lifecycleToken;
+    final @Nullable ITransaction transaction;
+
+    SentryRecordContext(
+        final @NotNull ISentryLifecycleToken lifecycleToken,
+        final @Nullable ITransaction transaction) {
+      this.lifecycleToken = lifecycleToken;
+      this.transaction = transaction;
+    }
+  }
+}
diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt
new file mode 100644
index 00000000000..3d52378e35a
--- /dev/null
+++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt
@@ -0,0 +1,124 @@
+package io.sentry.spring.jakarta.kafka
+
+import io.sentry.Sentry
+import io.sentry.test.initForTest
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory
+import org.springframework.kafka.core.ConsumerFactory
+import org.springframework.kafka.listener.RecordInterceptor
+
+class SentryKafkaConsumerBeanPostProcessorTest {
+
+  @BeforeTest
+  fun setup() {
+    initForTest { it.dsn = "https://key@sentry.io/proj" }
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+  }
+
+  @Test
+  fun `wraps ConcurrentKafkaListenerContainerFactory with SentryKafkaRecordInterceptor`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.consumerFactory = consumerFactory
+
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    // Verify via reflection that the interceptor was set
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    val interceptor = field.get(factory)
+    assertTrue(interceptor is SentryKafkaRecordInterceptor<*, *>)
+  }
+
+  @Test
+  fun `does not double-wrap when SentryKafkaRecordInterceptor already set`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.consumerFactory = consumerFactory
+
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+    // First wrap
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    val firstInterceptor = field.get(factory)
+
+    // Second wrap — should be idempotent
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+    val secondInterceptor = field.get(factory)
+
+    assertSame(firstInterceptor, secondInterceptor)
+  }
+
+  @Test
+  fun `does not wrap non-factory beans`() {
+    val someBean = "not a factory"
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(someBean, "someBean")
+
+    assertSame(someBean, result)
+  }
+
+  @Test
+  fun `chains existing customer RecordInterceptor as delegate`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.consumerFactory = consumerFactory
+
+    val customerInterceptor = RecordInterceptor<String, String> { record, _ -> record }
+    factory.setRecordInterceptor(customerInterceptor)
+
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    val installed = field.get(factory)
+    assertTrue(
+      installed is SentryKafkaRecordInterceptor<*, *>,
+      "expected SentryKafkaRecordInterceptor, got ${installed?.javaClass}",
+    )
+
+    val delegateField = SentryKafkaRecordInterceptor::class.java.getDeclaredField("delegate")
+    delegateField.isAccessible = true
+    assertSame(
+      customerInterceptor,
+      delegateField.get(installed),
+      "customer interceptor must be preserved as delegate",
+    )
+  }
+
+  @Test
+  fun `skips installation when reflection fails and preserves customer interceptor`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.consumerFactory = consumerFactory
+    val customerInterceptor = RecordInterceptor<String, String> { record, _ -> record }
+    factory.setRecordInterceptor(customerInterceptor)
+
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    assertSame(customerInterceptor, field.get(factory))
+
+    val processor = SentryKafkaConsumerBeanPostProcessor("missingRecordInterceptor")
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    assertSame(
+      customerInterceptor,
+      field.get(factory),
+      "customer interceptor must remain installed when Sentry cannot read it",
+    )
+  }
+}
diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaProducerBeanPostProcessorTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaProducerBeanPostProcessorTest.kt
new file mode 100644
index 00000000000..b3a1a268682
--- /dev/null
+++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaProducerBeanPostProcessorTest.kt
@@ -0,0 +1,109 @@
+package io.sentry.spring.jakarta.kafka
+
+import io.sentry.Sentry
+import io.sentry.test.initForTest
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.apache.kafka.clients.producer.Producer
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.springframework.kafka.core.DefaultKafkaProducerFactory
+import org.springframework.kafka.core.ProducerFactory
+import org.springframework.kafka.core.ProducerPostProcessor
+
+class SentryKafkaProducerBeanPostProcessorTest {
+
+  @BeforeTest
+  fun setup() {
+    initForTest { it.dsn = "https://key@sentry.io/proj" }
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+  }
+
+  @Test
+  fun `registers Sentry post-processor on ProducerFactory`() {
+    val factory = mock<ProducerFactory<String, String>>()
+    val pp = SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<String, String>()
+    whenever(factory.postProcessors).thenReturn(listOf(pp))
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    processor.postProcessAfterInitialization(factory, "kafkaProducerFactory")
+
+    val captor = argumentCaptor<ProducerPostProcessor<String, String>>()
+    verify(factory).addPostProcessor(captor.capture())
+    assertTrue(
+      captor.firstValue is SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<*, *>
+    )
+  }
+
+  @Test
+  fun `does not throw when addPostProcessor is a no-op (default interface method)`() {
+    // Factory using the default no-op addPostProcessor / getPostProcessors
+    val factory = mock<ProducerFactory<String, String>>()
+    whenever(factory.postProcessors).thenReturn(emptyList())
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    // Should complete without throwing, and log a warning via ScopesAdapter
+    processor.postProcessAfterInitialization(factory, "myFactory")
+
+    verify(factory).addPostProcessor(any())
+  }
+
+  @Test
+  fun `does not modify non-ProducerFactory beans`() {
+    val someBean = "not a producer factory"
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(someBean, "someBean")
+
+    assertSame(someBean, result)
+  }
+
+  @Test
+  fun `returns the same bean instance`() {
+    val factory = mock<ProducerFactory<String, String>>()
+    val pp = SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<String, String>()
+    whenever(factory.postProcessors).thenReturn(listOf(pp))
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(factory, "kafkaProducerFactory")
+
+    assertSame(factory, result, "BPP must return the same bean, not a replacement")
+  }
+
+  @Test
+  fun `registered post-processor wraps producers via SentryKafkaProducer wrap`() {
+    val pp = SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<String, String>()
+    val raw = mock<Producer<String, String>>()
+
+    val wrapped = pp.apply(raw)
+
+    assertTrue(java.lang.reflect.Proxy.isProxyClass(wrapped.javaClass))
+  }
+
+  @Test
+  fun `integrates with DefaultKafkaProducerFactory addPostProcessor contract`() {
+    // Sanity check against the real Spring Kafka API surface — DefaultKafkaProducerFactory
+    // honors addPostProcessor and exposes it via getPostProcessors().
+    val factory = DefaultKafkaProducerFactory<String, String>(emptyMap())
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    processor.postProcessAfterInitialization(factory, "kafkaProducerFactory")
+
+    assertEquals(1, factory.postProcessors.size)
+    assertTrue(
+      factory.postProcessors.first()
+        is SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<*, *>
+    )
+  }
+}
diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaRecordInterceptorTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaRecordInterceptorTest.kt
new file mode 100644
index 00000000000..b09d4f5e147
--- /dev/null
+++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/kafka/SentryKafkaRecordInterceptorTest.kt
@@ -0,0 +1,476 @@
+package io.sentry.spring.jakarta.kafka
+
+import io.sentry.BaggageHeader
+import io.sentry.IScopes
+import io.sentry.ISentryLifecycleToken
+import io.sentry.Sentry
+import io.sentry.SentryOptions
+import io.sentry.SentryTraceHeader
+import io.sentry.SentryTracer
+import io.sentry.SpanDataConvention
+import io.sentry.TransactionContext
+import io.sentry.kafka.SentryKafkaProducer
+import io.sentry.test.initForTest
+import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
+import java.util.Optional
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.apache.kafka.clients.consumer.Consumer
+import org.apache.kafka.clients.consumer.ConsumerRecord
+import org.apache.kafka.common.header.internals.RecordHeaders
+import org.apache.kafka.common.record.TimestampType
+import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.springframework.kafka.listener.RecordInterceptor
+import org.springframework.kafka.support.KafkaHeaders
+
+class SentryKafkaRecordInterceptorTest {
+
+  private lateinit var scopes: IScopes
+  private lateinit var forkedScopes: IScopes
+  private lateinit var options: SentryOptions
+  private lateinit var consumer: Consumer<String, String>
+  private lateinit var lifecycleToken: ISentryLifecycleToken
+  private lateinit var transaction: SentryTracer
+
+  @BeforeTest
+  fun setup() {
+    initForTest { it.dsn = "https://key@sentry.io/proj" }
+    scopes = mock()
+    consumer = mock()
+    lifecycleToken = mock()
+    options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        isEnableQueueTracing = true
+        tracesSampleRate = 1.0
+      }
+    whenever(scopes.options).thenReturn(options)
+    whenever(scopes.isEnabled).thenReturn(true)
+
+    forkedScopes = mock()
+    whenever(scopes.forkedRootScopes(any())).thenReturn(forkedScopes)
+    whenever(forkedScopes.options).thenReturn(options)
+    whenever(forkedScopes.makeCurrent()).thenReturn(lifecycleToken)
+
+    transaction = SentryTracer(TransactionContext("queue.process", "queue.process"), forkedScopes)
+    whenever(forkedScopes.startTransaction(any<TransactionContext>(), any()))
+      .thenReturn(transaction)
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+  }
+
+  private fun createRecord(
+    topic: String = "my-topic",
+    headers: RecordHeaders = RecordHeaders(),
+    serializedValueSize: Int = -1,
+  ): ConsumerRecord<String, String> {
+    return ConsumerRecord(
+      topic,
+      0,
+      0L,
+      System.currentTimeMillis(),
+      TimestampType.CREATE_TIME,
+      3,
+      serializedValueSize,
+      "key",
+      "value",
+      headers,
+      Optional.empty(),
+    )
+  }
+
+  private fun createRecordWithHeaders(
+    sentryTrace: String? = null,
+    baggage: String? = null,
+    baggageHeaders: List<String>? = null,
+    enqueuedTime: String? = null,
+    deliveryAttempt: Int? = null,
+  ): ConsumerRecord<String, String> {
+    val headers = RecordHeaders()
+    sentryTrace?.let {
+      headers.add(SentryTraceHeader.SENTRY_TRACE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    baggage?.let {
+      headers.add(BaggageHeader.BAGGAGE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    baggageHeaders?.forEach {
+      headers.add(BaggageHeader.BAGGAGE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    enqueuedTime?.let {
+      headers.add(
+        SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER,
+        it.toByteArray(StandardCharsets.UTF_8),
+      )
+    }
+    deliveryAttempt?.let {
+      headers.add(
+        KafkaHeaders.DELIVERY_ATTEMPT,
+        ByteBuffer.allocate(Int.SIZE_BYTES).putInt(it).array(),
+      )
+    }
+    val record = ConsumerRecord("my-topic", 0, 0L, "key", "value")
+    headers.forEach { record.headers().add(it) }
+    return record
+  }
+
+  @Test
+  fun `intercept forks root scopes`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    verify(scopes).forkedRootScopes("SentryKafkaRecordInterceptor")
+    verify(forkedScopes).makeCurrent()
+    verify(forkedScopes)
+      .startTransaction(
+        org.mockito.kotlin.check<TransactionContext> {
+          assertEquals("my-topic", it.name)
+          assertEquals("queue.process", it.operation)
+        },
+        any(),
+      )
+  }
+
+  @Test
+  fun `intercept continues trace from headers`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val sentryTraceValue = "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1"
+    val record = createRecordWithHeaders(sentryTrace = sentryTraceValue)
+
+    interceptor.intercept(record, consumer)
+
+    verify(forkedScopes)
+      .continueTrace(org.mockito.kotlin.eq(sentryTraceValue), org.mockito.kotlin.isNull())
+  }
+
+  @Test
+  fun `intercept calls continueTrace with null when no headers`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    verify(forkedScopes).continueTrace(org.mockito.kotlin.isNull(), org.mockito.kotlin.isNull())
+  }
+
+  @Test
+  fun `intercept passes all baggage headers to continueTrace`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val sentryTraceValue = "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1"
+    val record =
+      createRecordWithHeaders(
+        sentryTrace = sentryTraceValue,
+        baggageHeaders = listOf("third=party", "sentry-sample_rate=1"),
+      )
+
+    interceptor.intercept(record, consumer)
+
+    verify(forkedScopes)
+      .continueTrace(
+        org.mockito.kotlin.eq(sentryTraceValue),
+        org.mockito.kotlin.eq(listOf("third=party", "sentry-sample_rate=1")),
+      )
+  }
+
+  @Test
+  fun `sets body size from serializedValueSize`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord(serializedValueSize = 42)
+
+    interceptor.intercept(record, consumer)
+
+    assertEquals(42, transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE))
+  }
+
+  @Test
+  fun `does not set body size when serializedValueSize is negative`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord(serializedValueSize = -1)
+
+    interceptor.intercept(record, consumer)
+
+    assertNull(transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE))
+  }
+
+  @Test
+  fun `sets retry count from delivery attempt header`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecordWithHeaders(deliveryAttempt = 3)
+
+    interceptor.intercept(record, consumer)
+
+    assertEquals(2, transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT))
+  }
+
+  @Test
+  fun `does not set retry count when delivery attempt header is missing`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    assertNull(transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT))
+  }
+
+  @Test
+  fun `sets receive latency from enqueued time in epoch seconds`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val enqueuedTime = (System.currentTimeMillis() / 1000.0 - 1.0).toString()
+    val record = createRecordWithHeaders(enqueuedTime = enqueuedTime)
+
+    interceptor.intercept(record, consumer)
+
+    val latency = transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_RECEIVE_LATENCY)
+    assertTrue(latency is Long && latency >= 0)
+  }
+
+  @Test
+  fun `does not create span when queue tracing is disabled`() {
+    options.isEnableQueueTracing = false
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    val result = interceptor.intercept(record, consumer)
+
+    verify(scopes, never()).forkedRootScopes(any())
+    verify(forkedScopes, never()).makeCurrent()
+    assertEquals(record, result)
+  }
+
+  @Test
+  fun `does not create span when origin is ignored`() {
+    options.setIgnoredSpanOrigins(listOf(SentryKafkaRecordInterceptor.TRACE_ORIGIN))
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    val result = interceptor.intercept(record, consumer)
+
+    verify(scopes, never()).forkedRootScopes(any())
+    verify(forkedScopes, never()).makeCurrent()
+    assertEquals(record, result)
+  }
+
+  @Test
+  fun `delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    whenever(delegate.intercept(record, consumer)).thenReturn(record)
+
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    interceptor.intercept(record, consumer)
+
+    verify(delegate).intercept(record, consumer)
+  }
+
+  @Test
+  fun `success finishes transaction and delegates`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+    interceptor.success(record, consumer)
+
+    verify(delegate).success(record, consumer)
+  }
+
+  @Test
+  fun `failure finishes transaction with error and delegates`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+    val exception = RuntimeException("processing failed")
+
+    interceptor.intercept(record, consumer)
+    interceptor.failure(record, exception, consumer)
+
+    verify(delegate).failure(record, exception, consumer)
+  }
+
+  @Test
+  fun `afterRecord delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+
+    interceptor.afterRecord(record, consumer)
+
+    verify(delegate).afterRecord(record, consumer)
+  }
+
+  @Test
+  fun `trace origin is set correctly`() {
+    assertEquals(
+      "auto.queue.spring_jakarta.kafka.consumer",
+      SentryKafkaRecordInterceptor.TRACE_ORIGIN,
+    )
+  }
+
+  @Test
+  fun `clearThreadState cleans up stale context`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    interceptor.clearThreadState(consumer)
+
+    verify(lifecycleToken).close()
+  }
+
+  @Test
+  fun `clearThreadState is no-op when no context exists`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+
+    // should not throw
+    interceptor.clearThreadState(consumer)
+  }
+
+  @Test
+  fun `setupThreadState delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+
+    verify(delegate).setupThreadState(consumer)
+  }
+
+  @Test
+  fun `setupThreadState is no-op without delegate`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+
+    // should not throw
+    interceptor.setupThreadState(consumer)
+  }
+
+  @Test
+  fun `clearThreadState delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.clearThreadState(consumer)
+
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `clearThreadState delegates to existing interceptor even when sentry cleanup throws`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    whenever(lifecycleToken.close()).thenThrow(RuntimeException("boom"))
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    try {
+      interceptor.clearThreadState(consumer)
+    } catch (ignored: RuntimeException) {
+      // expected
+    }
+
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `full lifecycle intercept success clearThreadState closes token exactly once`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    whenever(delegate.intercept(record, consumer)).thenReturn(record)
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+    interceptor.intercept(record, consumer)
+    interceptor.success(record, consumer)
+    interceptor.clearThreadState(consumer)
+
+    // token closed once by success(); clearThreadState must not re-close it
+    verify(lifecycleToken, times(1)).close()
+    assertTrue(transaction.isFinished)
+    // delegate hooks still delegated across the full lifecycle
+    verify(delegate).setupThreadState(consumer)
+    verify(delegate).success(record, consumer)
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `when delegate intercept returns null clearThreadState still finishes transaction and closes token`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    // delegate filters the record — per Spring Kafka contract, success/failure will not be invoked
+    whenever(delegate.intercept(record, consumer)).thenReturn(null)
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+    val result = interceptor.intercept(record, consumer)
+    interceptor.clearThreadState(consumer)
+
+    assertNull(result)
+    verify(lifecycleToken, times(1)).close()
+    assertTrue(transaction.isFinished)
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `when delegate intercept throws clearThreadState still finishes transaction and closes token`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    val boom = RuntimeException("delegate boom")
+    whenever(delegate.intercept(record, consumer)).thenThrow(boom)
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+    val thrown = assertFailsWith<RuntimeException> { interceptor.intercept(record, consumer) }
+    assertEquals(boom, thrown)
+
+    interceptor.clearThreadState(consumer)
+
+    verify(lifecycleToken, times(1)).close()
+    assertTrue(transaction.isFinished)
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `intercept cleans up stale context from previous record`() {
+    val lifecycleToken2 = mock<ISentryLifecycleToken>()
+    val forkedScopes2 = mock<IScopes>()
+    whenever(forkedScopes2.options).thenReturn(options)
+    whenever(forkedScopes2.makeCurrent()).thenReturn(lifecycleToken2)
+    val tx2 = SentryTracer(TransactionContext("queue.process", "queue.process"), forkedScopes2)
+    whenever(forkedScopes2.startTransaction(any<TransactionContext>(), any())).thenReturn(tx2)
+
+    var callCount = 0
+
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    whenever(scopes.forkedRootScopes(any())).thenAnswer {
+      callCount++
+      if (callCount == 1) forkedScopes else forkedScopes2
+    }
+
+    // First intercept sets up context
+    interceptor.intercept(record, consumer)
+
+    // Second intercept without success/failure — should clean up stale context first
+    interceptor.intercept(record, consumer)
+
+    // First lifecycle token should have been closed by the defensive cleanup
+    verify(lifecycleToken).close()
+  }
+}
diff --git a/sentry-spring/api/sentry-spring.api b/sentry-spring/api/sentry-spring.api
index 7148277e2ef..4e1bea84288 100644
--- a/sentry-spring/api/sentry-spring.api
+++ b/sentry-spring/api/sentry-spring.api
@@ -234,6 +234,30 @@ public final class io/sentry/spring/graphql/SentrySpringSubscriptionHandler : io
 	public fun onSubscriptionResult (Ljava/lang/Object;Lio/sentry/IScopes;Lio/sentry/graphql/ExceptionReporter;Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;)Ljava/lang/Object;
 }
 
+public final class io/sentry/spring/kafka/SentryKafkaConsumerBeanPostProcessor : org/springframework/beans/factory/config/BeanPostProcessor, org/springframework/core/PriorityOrdered {
+	public fun <init> ()V
+	public fun getOrder ()I
+	public fun postProcessAfterInitialization (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class io/sentry/spring/kafka/SentryKafkaProducerBeanPostProcessor : org/springframework/beans/factory/config/BeanPostProcessor, org/springframework/core/PriorityOrdered {
+	public fun <init> ()V
+	public fun getOrder ()I
+	public fun postProcessAfterInitialization (Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;
+}
+
+public final class io/sentry/spring/kafka/SentryKafkaRecordInterceptor : org/springframework/kafka/listener/RecordInterceptor {
+	public fun <init> (Lio/sentry/IScopes;)V
+	public fun <init> (Lio/sentry/IScopes;Lorg/springframework/kafka/listener/RecordInterceptor;)V
+	public fun afterRecord (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun clearThreadState (Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun failure (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Ljava/lang/Exception;Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun intercept (Lorg/apache/kafka/clients/consumer/ConsumerRecord;)Lorg/apache/kafka/clients/consumer/ConsumerRecord;
+	public fun intercept (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Lorg/apache/kafka/clients/consumer/Consumer;)Lorg/apache/kafka/clients/consumer/ConsumerRecord;
+	public fun setupThreadState (Lorg/apache/kafka/clients/consumer/Consumer;)V
+	public fun success (Lorg/apache/kafka/clients/consumer/ConsumerRecord;Lorg/apache/kafka/clients/consumer/Consumer;)V
+}
+
 public class io/sentry/spring/opentelemetry/SentryOpenTelemetryAgentWithoutAutoInitConfiguration {
 	public fun <init> ()V
 	public fun sentryOpenTelemetryOptionsConfiguration ()Lio/sentry/Sentry$OptionsConfiguration;
diff --git a/sentry-spring/build.gradle.kts b/sentry-spring/build.gradle.kts
index b651a9e62b2..c4c75cb5f07 100644
--- a/sentry-spring/build.gradle.kts
+++ b/sentry-spring/build.gradle.kts
@@ -27,6 +27,7 @@ dependencies {
   compileOnly(Config.Libs.aspectj)
   compileOnly(Config.Libs.springWebflux)
   compileOnly(projects.sentryGraphql)
+  compileOnly(projects.sentryKafka)
   compileOnly(projects.sentryQuartz)
   compileOnly(libs.jetbrains.annotations)
   compileOnly(libs.nopen.annotations)
@@ -35,6 +36,7 @@ dependencies {
   compileOnly(libs.slf4j.api)
   compileOnly(libs.springboot.starter.graphql)
   compileOnly(libs.springboot.starter.quartz)
+  compileOnly(libs.spring.kafka2)
   compileOnly(projects.sentryOpentelemetry.sentryOpentelemetryAgentcustomization)
   compileOnly(projects.sentryOpentelemetry.sentryOpentelemetryBootstrap)
 
@@ -45,6 +47,7 @@ dependencies {
   // tests
   testImplementation(projects.sentryTestSupport)
   testImplementation(projects.sentryGraphql)
+  testImplementation(projects.sentryKafka)
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(libs.awaitility.kotlin)
   testImplementation(libs.graphql.java17)
@@ -54,6 +57,7 @@ dependencies {
   testImplementation(libs.springboot.starter.aop)
   testImplementation(libs.springboot.starter.graphql)
   testImplementation(libs.springboot.starter.security)
+  testImplementation(libs.spring.kafka2)
   testImplementation(libs.springboot.starter.test)
   testImplementation(libs.springboot.starter.web)
   testImplementation(libs.springboot.starter.webflux)
diff --git a/sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaConsumerBeanPostProcessor.java b/sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaConsumerBeanPostProcessor.java
new file mode 100644
index 00000000000..7a3ba1caa27
--- /dev/null
+++ b/sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaConsumerBeanPostProcessor.java
@@ -0,0 +1,98 @@
+package io.sentry.spring.kafka;
+
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryLevel;
+import java.lang.reflect.Field;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.core.Ordered;
+import org.springframework.core.PriorityOrdered;
+import org.springframework.kafka.config.AbstractKafkaListenerContainerFactory;
+import org.springframework.kafka.listener.RecordInterceptor;
+
+/**
+ * Registers {@link SentryKafkaRecordInterceptor} on {@link AbstractKafkaListenerContainerFactory}
+ * beans. If an existing {@link RecordInterceptor} is already set, it is composed as a delegate.
+ */
+@ApiStatus.Internal
+public final class SentryKafkaConsumerBeanPostProcessor
+    implements BeanPostProcessor, PriorityOrdered {
+
+  private static final @NotNull String RECORD_INTERCEPTOR_FIELD_NAME = "recordInterceptor";
+
+  private final @NotNull String recordInterceptorFieldName;
+
+  public SentryKafkaConsumerBeanPostProcessor() {
+    this(RECORD_INTERCEPTOR_FIELD_NAME);
+  }
+
+  SentryKafkaConsumerBeanPostProcessor(final @NotNull String recordInterceptorFieldName) {
+    this.recordInterceptorFieldName = recordInterceptorFieldName;
+  }
+
+  private static final class InterceptorReadFailedException extends Exception {
+    private static final long serialVersionUID = 1L;
+
+    InterceptorReadFailedException(final @NotNull Throwable cause) {
+      super(cause);
+    }
+  }
+
+  @Override
+  @SuppressWarnings("unchecked")
+  public @NotNull Object postProcessAfterInitialization(
+      final @NotNull Object bean, final @NotNull String beanName) throws BeansException {
+    if (bean instanceof AbstractKafkaListenerContainerFactory) {
+      final @NotNull AbstractKafkaListenerContainerFactory<?, ?, ?> factory =
+          (AbstractKafkaListenerContainerFactory<?, ?, ?>) bean;
+
+      final @Nullable RecordInterceptor<?, ?> existing;
+      try {
+        existing = getExistingInterceptor(factory);
+      } catch (InterceptorReadFailedException e) {
+        ScopesAdapter.getInstance()
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.ERROR,
+                e,
+                "Sentry Kafka consumer tracing disabled for factory '%s' \u2014 could not read "
+                    + "existing recordInterceptor via reflection. Refusing to install Sentry's "
+                    + "interceptor to avoid overwriting a customer-configured RecordInterceptor.",
+                beanName);
+        return bean;
+      }
+
+      if (existing instanceof SentryKafkaRecordInterceptor) {
+        return bean;
+      }
+
+      @SuppressWarnings("rawtypes")
+      final RecordInterceptor sentryInterceptor =
+          new SentryKafkaRecordInterceptor<>(ScopesAdapter.getInstance(), existing);
+      factory.setRecordInterceptor(sentryInterceptor);
+    }
+    return bean;
+  }
+
+  private @Nullable RecordInterceptor<?, ?> getExistingInterceptor(
+      final @NotNull AbstractKafkaListenerContainerFactory<?, ?, ?> factory)
+      throws InterceptorReadFailedException {
+    try {
+      final @NotNull Field field =
+          AbstractKafkaListenerContainerFactory.class.getDeclaredField(recordInterceptorFieldName);
+      field.setAccessible(true);
+      return (RecordInterceptor<?, ?>) field.get(factory);
+    } catch (NoSuchFieldException | IllegalAccessException | RuntimeException e) {
+      throw new InterceptorReadFailedException(e);
+    }
+  }
+
+  @Override
+  public int getOrder() {
+    return Ordered.LOWEST_PRECEDENCE;
+  }
+}
diff --git a/sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaProducerBeanPostProcessor.java b/sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaProducerBeanPostProcessor.java
new file mode 100644
index 00000000000..7b3266a3510
--- /dev/null
+++ b/sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaProducerBeanPostProcessor.java
@@ -0,0 +1,76 @@
+package io.sentry.spring.kafka;
+
+import io.sentry.ScopesAdapter;
+import io.sentry.SentryLevel;
+import io.sentry.kafka.SentryKafkaProducer;
+import org.apache.kafka.clients.producer.Producer;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.config.BeanPostProcessor;
+import org.springframework.core.Ordered;
+import org.springframework.core.PriorityOrdered;
+import org.springframework.kafka.core.ProducerFactory;
+import org.springframework.kafka.core.ProducerPostProcessor;
+
+/**
+ * Installs a {@link ProducerPostProcessor} on every {@link ProducerFactory} bean so that each
+ * {@link Producer} created by Spring Kafka is wrapped via {@link SentryKafkaProducer#wrap
+ * SentryKafkaProducer.wrap(Producer)}.
+ *
+ * <p>The wrapper records a {@code queue.publish} span around each {@code send(...)} that finishes
+ * when the broker ack callback fires, giving a real producer-send lifecycle span. {@code
+ * KafkaTemplate} beans are left untouched, so all customer-configured listeners, interceptors and
+ * observation settings are preserved.
+ *
+ * <p>Note: {@link ProducerFactory#addPostProcessor(ProducerPostProcessor)} is a default method on
+ * the interface that is a no-op unless overridden. Custom factories that do not extend {@code
+ * DefaultKafkaProducerFactory} will not receive Sentry producer instrumentation; a warning is
+ * logged at startup in that case.
+ */
+@ApiStatus.Internal
+public final class SentryKafkaProducerBeanPostProcessor
+    implements BeanPostProcessor, PriorityOrdered {
+
+  @Override
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public @NotNull Object postProcessAfterInitialization(
+      final @NotNull Object bean, final @NotNull String beanName) throws BeansException {
+    if (bean instanceof ProducerFactory) {
+      final @NotNull ProducerFactory factory = (ProducerFactory) bean;
+      final @NotNull SentryProducerPostProcessor pp = new SentryProducerPostProcessor<>();
+      factory.addPostProcessor(pp);
+      if (!factory.getPostProcessors().contains(pp)) {
+        ScopesAdapter.getInstance()
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.WARNING,
+                "Sentry Kafka producer tracing not active for ProducerFactory '%s' (%s). "
+                    + "addPostProcessor() was not honored — the factory may not extend "
+                    + "DefaultKafkaProducerFactory. Wrap producers manually with "
+                    + "SentryKafkaProducer.wrap(producer).",
+                beanName,
+                factory.getClass().getName());
+      }
+    }
+    return bean;
+  }
+
+  @Override
+  public int getOrder() {
+    return Ordered.LOWEST_PRECEDENCE;
+  }
+
+  /**
+   * Marker {@link ProducerPostProcessor} that wraps the freshly created Kafka {@link Producer} via
+   * {@link SentryKafkaProducer#wrap}.
+   */
+  static final class SentryProducerPostProcessor<K, V> implements ProducerPostProcessor<K, V> {
+    @Override
+    public @NotNull Producer<K, V> apply(final @NotNull Producer<K, V> producer) {
+      return SentryKafkaProducer.wrap(
+          producer, ScopesAdapter.getInstance(), "auto.queue.spring.kafka.producer");
+    }
+  }
+}
diff --git a/sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaRecordInterceptor.java b/sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaRecordInterceptor.java
new file mode 100644
index 00000000000..d1ad3086098
--- /dev/null
+++ b/sentry-spring/src/main/java/io/sentry/spring/kafka/SentryKafkaRecordInterceptor.java
@@ -0,0 +1,298 @@
+package io.sentry.spring.kafka;
+
+import io.sentry.BaggageHeader;
+import io.sentry.DateUtils;
+import io.sentry.IScopes;
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.ITransaction;
+import io.sentry.SentryLevel;
+import io.sentry.SentryTraceHeader;
+import io.sentry.SpanDataConvention;
+import io.sentry.SpanStatus;
+import io.sentry.TransactionContext;
+import io.sentry.TransactionOptions;
+import io.sentry.kafka.SentryKafkaProducer;
+import io.sentry.util.SpanUtils;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import org.apache.kafka.clients.consumer.Consumer;
+import org.apache.kafka.clients.consumer.ConsumerRecord;
+import org.apache.kafka.common.header.Header;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.kafka.listener.RecordInterceptor;
+import org.springframework.kafka.support.KafkaHeaders;
+
+/**
+ * A {@link RecordInterceptor} that creates {@code queue.process} transactions for incoming Kafka
+ * records with distributed tracing support.
+ */
+@ApiStatus.Internal
+@SuppressWarnings("deprecation")
+public final class SentryKafkaRecordInterceptor<K, V> implements RecordInterceptor<K, V> {
+
+  static final String TRACE_ORIGIN = "auto.queue.spring.kafka.consumer";
+
+  private final @NotNull IScopes scopes;
+  private final @Nullable RecordInterceptor<K, V> delegate;
+
+  private static final @NotNull ThreadLocal<SentryRecordContext> currentContext =
+      new ThreadLocal<>();
+
+  public SentryKafkaRecordInterceptor(final @NotNull IScopes scopes) {
+    this(scopes, null);
+  }
+
+  public SentryKafkaRecordInterceptor(
+      final @NotNull IScopes scopes, final @Nullable RecordInterceptor<K, V> delegate) {
+    this.scopes = scopes;
+    this.delegate = delegate;
+  }
+
+  @Override
+  public @Nullable ConsumerRecord<K, V> intercept(final @NotNull ConsumerRecord<K, V> record) {
+    return intercept(record, null);
+  }
+
+  @Override
+  public @Nullable ConsumerRecord<K, V> intercept(
+      final @NotNull ConsumerRecord<K, V> record, final @Nullable Consumer<K, V> consumer) {
+    if (!scopes.getOptions().isEnableQueueTracing() || isIgnored()) {
+      return delegateIntercept(record, consumer);
+    }
+
+    try {
+      finishStaleContext();
+
+      final @NotNull IScopes forkedScopes = scopes.forkedRootScopes("SentryKafkaRecordInterceptor");
+      final @NotNull ISentryLifecycleToken lifecycleToken = forkedScopes.makeCurrent();
+      currentContext.set(new SentryRecordContext(lifecycleToken, null));
+
+      final @Nullable TransactionContext transactionContext = continueTrace(forkedScopes, record);
+
+      final @Nullable ITransaction transaction =
+          startTransaction(forkedScopes, record, transactionContext);
+      currentContext.set(new SentryRecordContext(lifecycleToken, transaction));
+    } catch (Throwable t) {
+      scopes.getOptions().getLogger().log(SentryLevel.ERROR, "Unable to wrap Kafka consumer.", t);
+    }
+    return delegateIntercept(record, consumer);
+  }
+
+  @Override
+  public void success(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    try {
+      if (delegate != null) {
+        delegate.success(record, consumer);
+      }
+    } finally {
+      finishSpan(SpanStatus.OK, null);
+    }
+  }
+
+  @Override
+  public void failure(
+      final @NotNull ConsumerRecord<K, V> record,
+      final @NotNull Exception exception,
+      final @NotNull Consumer<K, V> consumer) {
+    try {
+      if (delegate != null) {
+        delegate.failure(record, exception, consumer);
+      }
+    } finally {
+      finishSpan(SpanStatus.INTERNAL_ERROR, exception);
+    }
+  }
+
+  @Override
+  public void afterRecord(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull Consumer<K, V> consumer) {
+    if (delegate != null) {
+      delegate.afterRecord(record, consumer);
+    }
+  }
+
+  @Override
+  public void setupThreadState(final @NotNull Consumer<?, ?> consumer) {
+    if (delegate != null) {
+      delegate.setupThreadState(consumer);
+    }
+  }
+
+  @Override
+  public void clearThreadState(final @NotNull Consumer<?, ?> consumer) {
+    try {
+      finishStaleContext();
+    } finally {
+      if (delegate != null) {
+        delegate.clearThreadState(consumer);
+      }
+    }
+  }
+
+  private boolean isIgnored() {
+    return SpanUtils.isIgnored(scopes.getOptions().getIgnoredSpanOrigins(), TRACE_ORIGIN);
+  }
+
+  private @Nullable ConsumerRecord<K, V> delegateIntercept(
+      final @NotNull ConsumerRecord<K, V> record, final @Nullable Consumer<K, V> consumer) {
+    if (delegate != null) {
+      return consumer != null ? delegate.intercept(record, consumer) : delegate.intercept(record);
+    }
+    return record;
+  }
+
+  private @Nullable TransactionContext continueTrace(
+      final @NotNull IScopes forkedScopes, final @NotNull ConsumerRecord<K, V> record) {
+    final @Nullable String sentryTrace = headerValue(record, SentryTraceHeader.SENTRY_TRACE_HEADER);
+    final @Nullable List<String> baggageHeaders =
+        headerValues(record, BaggageHeader.BAGGAGE_HEADER);
+    return forkedScopes.continueTrace(sentryTrace, baggageHeaders);
+  }
+
+  private @Nullable ITransaction startTransaction(
+      final @NotNull IScopes forkedScopes,
+      final @NotNull ConsumerRecord<K, V> record,
+      final @Nullable TransactionContext transactionContext) {
+    if (!forkedScopes.getOptions().isTracingEnabled()) {
+      return null;
+    }
+
+    final @NotNull TransactionContext txContext =
+        transactionContext != null
+            ? transactionContext
+            : new TransactionContext(record.topic(), "queue.process");
+    txContext.setName(record.topic());
+    txContext.setOperation("queue.process");
+
+    final @NotNull TransactionOptions txOptions = new TransactionOptions();
+    txOptions.setOrigin(TRACE_ORIGIN);
+    txOptions.setBindToScope(true);
+
+    final @NotNull ITransaction transaction = forkedScopes.startTransaction(txContext, txOptions);
+
+    if (transaction.isNoOp()) {
+      return null;
+    }
+
+    transaction.setData(SpanDataConvention.MESSAGING_SYSTEM, "kafka");
+    transaction.setData(SpanDataConvention.MESSAGING_DESTINATION_NAME, record.topic());
+
+    final @Nullable String messageId = headerValue(record, "messaging.message.id");
+    if (messageId != null) {
+      transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_ID, messageId);
+    }
+
+    final int bodySize = record.serializedValueSize();
+    if (bodySize >= 0) {
+      transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE, bodySize);
+    }
+
+    final @Nullable Integer retryCount = retryCount(record);
+    if (retryCount != null) {
+      transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT, retryCount);
+    }
+
+    final @Nullable String enqueuedTimeStr =
+        headerValue(record, SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER);
+    if (enqueuedTimeStr != null) {
+      try {
+        final double enqueuedTimeSeconds = Double.parseDouble(enqueuedTimeStr);
+        final double nowSeconds = DateUtils.millisToSeconds(System.currentTimeMillis());
+        final long latencyMs = (long) ((nowSeconds - enqueuedTimeSeconds) * 1000);
+        if (latencyMs >= 0) {
+          transaction.setData(SpanDataConvention.MESSAGING_MESSAGE_RECEIVE_LATENCY, latencyMs);
+        }
+      } catch (NumberFormatException ignored) {
+        // ignore malformed header
+      }
+    }
+
+    return transaction;
+  }
+
+  private @Nullable Integer retryCount(final @NotNull ConsumerRecord<K, V> record) {
+    final @Nullable Header header = record.headers().lastHeader(KafkaHeaders.DELIVERY_ATTEMPT);
+    if (header == null) {
+      return null;
+    }
+
+    final byte[] value = header.value();
+    if (value == null || value.length != Integer.BYTES) {
+      return null;
+    }
+
+    final int attempt = ByteBuffer.wrap(value).getInt();
+    if (attempt <= 0) {
+      return null;
+    }
+
+    return attempt - 1;
+  }
+
+  private void finishStaleContext() {
+    if (currentContext.get() != null) {
+      finishSpan(SpanStatus.UNKNOWN, null);
+    }
+  }
+
+  private void finishSpan(final @NotNull SpanStatus status, final @Nullable Throwable throwable) {
+    final @Nullable SentryRecordContext ctx = currentContext.get();
+    if (ctx == null) {
+      return;
+    }
+    currentContext.remove();
+
+    try {
+      final @Nullable ITransaction transaction = ctx.transaction;
+      if (transaction != null) {
+        transaction.setStatus(status);
+        if (throwable != null) {
+          transaction.setThrowable(throwable);
+        }
+        transaction.finish();
+      }
+    } finally {
+      ctx.lifecycleToken.close();
+    }
+  }
+
+  private @Nullable String headerValue(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull String headerName) {
+    final @Nullable Header header = record.headers().lastHeader(headerName);
+    if (header == null || header.value() == null) {
+      return null;
+    }
+    return new String(header.value(), StandardCharsets.UTF_8);
+  }
+
+  private @Nullable List<String> headerValues(
+      final @NotNull ConsumerRecord<K, V> record, final @NotNull String headerName) {
+    @Nullable List<String> values = null;
+    for (final @NotNull Header header : record.headers().headers(headerName)) {
+      if (header.value() != null) {
+        if (values == null) {
+          values = new ArrayList<>();
+        }
+        values.add(new String(header.value(), StandardCharsets.UTF_8));
+      }
+    }
+    return values;
+  }
+
+  private static final class SentryRecordContext {
+    final @NotNull ISentryLifecycleToken lifecycleToken;
+    final @Nullable ITransaction transaction;
+
+    SentryRecordContext(
+        final @NotNull ISentryLifecycleToken lifecycleToken,
+        final @Nullable ITransaction transaction) {
+      this.lifecycleToken = lifecycleToken;
+      this.transaction = transaction;
+    }
+  }
+}
diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/exception/SentryCaptureExceptionParameterAdviceTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/exception/SentryCaptureExceptionParameterAdviceTest.kt
index f7b43867252..29ab6683450 100644
--- a/sentry-spring/src/test/kotlin/io/sentry/spring/exception/SentryCaptureExceptionParameterAdviceTest.kt
+++ b/sentry-spring/src/test/kotlin/io/sentry/spring/exception/SentryCaptureExceptionParameterAdviceTest.kt
@@ -4,6 +4,8 @@ import io.sentry.Hint
 import io.sentry.IScopes
 import io.sentry.Sentry
 import io.sentry.exception.ExceptionMechanismException
+import io.sentry.test.initForTest
+import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -32,6 +34,13 @@ class SentryCaptureExceptionParameterAdviceTest {
   @BeforeTest
   fun setup() {
     reset(scopes)
+    initForTest { it.dsn = "https://key@sentry.io/proj" }
+    Sentry.setCurrentScopes(scopes)
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
   }
 
   @Test
diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt
new file mode 100644
index 00000000000..76dfd81cd0b
--- /dev/null
+++ b/sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaConsumerBeanPostProcessorTest.kt
@@ -0,0 +1,110 @@
+package io.sentry.spring.kafka
+
+import kotlin.test.Test
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory
+import org.springframework.kafka.core.ConsumerFactory
+import org.springframework.kafka.listener.RecordInterceptor
+
+class SentryKafkaConsumerBeanPostProcessorTest {
+
+  @Test
+  fun `wraps ConcurrentKafkaListenerContainerFactory with SentryKafkaRecordInterceptor`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.consumerFactory = consumerFactory
+
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    // Verify via reflection that the interceptor was set
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    val interceptor = field.get(factory)
+    assertTrue(interceptor is SentryKafkaRecordInterceptor<*, *>)
+  }
+
+  @Test
+  fun `does not double-wrap when SentryKafkaRecordInterceptor already set`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.consumerFactory = consumerFactory
+
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+    // First wrap
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    val firstInterceptor = field.get(factory)
+
+    // Second wrap — should be idempotent
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+    val secondInterceptor = field.get(factory)
+
+    assertSame(firstInterceptor, secondInterceptor)
+  }
+
+  @Test
+  fun `does not wrap non-factory beans`() {
+    val someBean = "not a factory"
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(someBean, "someBean")
+
+    assertSame(someBean, result)
+  }
+
+  @Test
+  fun `chains existing customer RecordInterceptor as delegate`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.consumerFactory = consumerFactory
+
+    val customerInterceptor = RecordInterceptor<String, String> { record -> record }
+    factory.setRecordInterceptor(customerInterceptor)
+
+    val processor = SentryKafkaConsumerBeanPostProcessor()
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    val installed = field.get(factory)
+    assertTrue(
+      installed is SentryKafkaRecordInterceptor<*, *>,
+      "expected SentryKafkaRecordInterceptor, got ${installed?.javaClass}",
+    )
+
+    val delegateField = SentryKafkaRecordInterceptor::class.java.getDeclaredField("delegate")
+    delegateField.isAccessible = true
+    assertSame(
+      customerInterceptor,
+      delegateField.get(installed),
+      "customer interceptor must be preserved as delegate",
+    )
+  }
+
+  @Test
+  fun `skips installation when reflection fails and preserves customer interceptor`() {
+    val consumerFactory = mock<ConsumerFactory<String, String>>()
+    val factory = ConcurrentKafkaListenerContainerFactory<String, String>()
+    factory.consumerFactory = consumerFactory
+    val customerInterceptor = RecordInterceptor<String, String> { record -> record }
+    factory.setRecordInterceptor(customerInterceptor)
+
+    val field = factory.javaClass.superclass.getDeclaredField("recordInterceptor")
+    field.isAccessible = true
+    assertSame(customerInterceptor, field.get(factory))
+
+    val processor = SentryKafkaConsumerBeanPostProcessor("missingRecordInterceptor")
+    processor.postProcessAfterInitialization(factory, "kafkaListenerContainerFactory")
+
+    assertSame(
+      customerInterceptor,
+      field.get(factory),
+      "customer interceptor must remain installed when Sentry cannot read it",
+    )
+  }
+}
diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaProducerBeanPostProcessorTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaProducerBeanPostProcessorTest.kt
new file mode 100644
index 00000000000..11a943307c8
--- /dev/null
+++ b/sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaProducerBeanPostProcessorTest.kt
@@ -0,0 +1,95 @@
+package io.sentry.spring.kafka
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.apache.kafka.clients.producer.Producer
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.springframework.kafka.core.DefaultKafkaProducerFactory
+import org.springframework.kafka.core.ProducerFactory
+import org.springframework.kafka.core.ProducerPostProcessor
+
+class SentryKafkaProducerBeanPostProcessorTest {
+
+  @Test
+  fun `registers Sentry post-processor on ProducerFactory`() {
+    val factory = mock<ProducerFactory<String, String>>()
+    val pp = SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<String, String>()
+    whenever(factory.postProcessors).thenReturn(listOf(pp))
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    processor.postProcessAfterInitialization(factory, "kafkaProducerFactory")
+
+    val captor = argumentCaptor<ProducerPostProcessor<String, String>>()
+    verify(factory).addPostProcessor(captor.capture())
+    assertTrue(
+      captor.firstValue is SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<*, *>
+    )
+  }
+
+  @Test
+  fun `does not throw when addPostProcessor is a no-op (default interface method)`() {
+    // Factory using the default no-op addPostProcessor / getPostProcessors
+    val factory = mock<ProducerFactory<String, String>>()
+    whenever(factory.postProcessors).thenReturn(emptyList())
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    // Should complete without throwing, and log a warning via ScopesAdapter
+    processor.postProcessAfterInitialization(factory, "myFactory")
+
+    verify(factory).addPostProcessor(any())
+  }
+
+  @Test
+  fun `does not modify non-ProducerFactory beans`() {
+    val someBean = "not a producer factory"
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(someBean, "someBean")
+
+    assertSame(someBean, result)
+  }
+
+  @Test
+  fun `returns the same bean instance`() {
+    val factory = mock<ProducerFactory<String, String>>()
+    val pp = SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<String, String>()
+    whenever(factory.postProcessors).thenReturn(listOf(pp))
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    val result = processor.postProcessAfterInitialization(factory, "kafkaProducerFactory")
+
+    assertSame(factory, result, "BPP must return the same bean, not a replacement")
+  }
+
+  @Test
+  fun `registered post-processor wraps producers via SentryKafkaProducer wrap`() {
+    val pp = SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<String, String>()
+    val raw = mock<Producer<String, String>>()
+
+    val wrapped = pp.apply(raw)
+
+    assertTrue(java.lang.reflect.Proxy.isProxyClass(wrapped.javaClass))
+  }
+
+  @Test
+  fun `integrates with DefaultKafkaProducerFactory addPostProcessor contract`() {
+    // Sanity check against the real Spring Kafka API surface — DefaultKafkaProducerFactory
+    // honors addPostProcessor and exposes it via getPostProcessors().
+    val factory = DefaultKafkaProducerFactory<String, String>(emptyMap())
+    val processor = SentryKafkaProducerBeanPostProcessor()
+
+    processor.postProcessAfterInitialization(factory, "kafkaProducerFactory")
+
+    assertEquals(1, factory.postProcessors.size)
+    assertTrue(
+      factory.postProcessors.first()
+        is SentryKafkaProducerBeanPostProcessor.SentryProducerPostProcessor<*, *>
+    )
+  }
+}
diff --git a/sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaRecordInterceptorTest.kt b/sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaRecordInterceptorTest.kt
new file mode 100644
index 00000000000..17df004d40c
--- /dev/null
+++ b/sentry-spring/src/test/kotlin/io/sentry/spring/kafka/SentryKafkaRecordInterceptorTest.kt
@@ -0,0 +1,486 @@
+package io.sentry.spring.kafka
+
+import io.sentry.BaggageHeader
+import io.sentry.IScopes
+import io.sentry.ISentryLifecycleToken
+import io.sentry.Sentry
+import io.sentry.SentryOptions
+import io.sentry.SentryTraceHeader
+import io.sentry.SentryTracer
+import io.sentry.SpanDataConvention
+import io.sentry.TransactionContext
+import io.sentry.kafka.SentryKafkaProducer
+import io.sentry.test.initForTest
+import java.nio.ByteBuffer
+import java.nio.charset.StandardCharsets
+import java.util.Optional
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.apache.kafka.clients.consumer.Consumer
+import org.apache.kafka.clients.consumer.ConsumerRecord
+import org.apache.kafka.common.header.internals.RecordHeaders
+import org.apache.kafka.common.record.TimestampType
+import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.springframework.kafka.listener.RecordInterceptor
+import org.springframework.kafka.support.KafkaHeaders
+
+class SentryKafkaRecordInterceptorTest {
+
+  private lateinit var scopes: IScopes
+  private lateinit var forkedScopes: IScopes
+  private lateinit var options: SentryOptions
+  private lateinit var consumer: Consumer<String, String>
+  private lateinit var lifecycleToken: ISentryLifecycleToken
+  private lateinit var transaction: SentryTracer
+
+  @BeforeTest
+  fun setup() {
+    initForTest { it.dsn = "https://key@sentry.io/proj" }
+    scopes = mock()
+    consumer = mock()
+    lifecycleToken = mock()
+    options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        isEnableQueueTracing = true
+        tracesSampleRate = 1.0
+      }
+    whenever(scopes.options).thenReturn(options)
+    whenever(scopes.isEnabled).thenReturn(true)
+
+    forkedScopes = mock()
+    whenever(scopes.forkedRootScopes(any())).thenReturn(forkedScopes)
+    whenever(forkedScopes.options).thenReturn(options)
+    whenever(forkedScopes.makeCurrent()).thenReturn(lifecycleToken)
+
+    transaction = SentryTracer(TransactionContext("queue.process", "queue.process"), forkedScopes)
+    whenever(forkedScopes.startTransaction(any<TransactionContext>(), any()))
+      .thenReturn(transaction)
+  }
+
+  @AfterTest
+  fun teardown() {
+    Sentry.close()
+  }
+
+  private fun createRecord(
+    topic: String = "my-topic",
+    headers: RecordHeaders = RecordHeaders(),
+    serializedValueSize: Int = -1,
+  ): ConsumerRecord<String, String> {
+    return ConsumerRecord(
+      topic,
+      0,
+      0L,
+      System.currentTimeMillis(),
+      TimestampType.CREATE_TIME,
+      3,
+      serializedValueSize,
+      "key",
+      "value",
+      headers,
+      Optional.empty(),
+    )
+  }
+
+  private fun createRecordWithHeaders(
+    sentryTrace: String? = null,
+    baggage: String? = null,
+    baggageHeaders: List<String>? = null,
+    enqueuedTime: String? = null,
+    deliveryAttempt: Int? = null,
+  ): ConsumerRecord<String, String> {
+    val headers = RecordHeaders()
+    sentryTrace?.let {
+      headers.add(SentryTraceHeader.SENTRY_TRACE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    baggage?.let {
+      headers.add(BaggageHeader.BAGGAGE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    baggageHeaders?.forEach {
+      headers.add(BaggageHeader.BAGGAGE_HEADER, it.toByteArray(StandardCharsets.UTF_8))
+    }
+    enqueuedTime?.let {
+      headers.add(
+        SentryKafkaProducer.SENTRY_ENQUEUED_TIME_HEADER,
+        it.toByteArray(StandardCharsets.UTF_8),
+      )
+    }
+    deliveryAttempt?.let {
+      headers.add(
+        KafkaHeaders.DELIVERY_ATTEMPT,
+        ByteBuffer.allocate(Int.SIZE_BYTES).putInt(it).array(),
+      )
+    }
+    val record = ConsumerRecord<String, String>("my-topic", 0, 0L, "key", "value")
+    headers.forEach { record.headers().add(it) }
+    return record
+  }
+
+  @Test
+  fun `intercept forks root scopes`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    verify(scopes).forkedRootScopes("SentryKafkaRecordInterceptor")
+    verify(forkedScopes).makeCurrent()
+    verify(forkedScopes)
+      .startTransaction(
+        org.mockito.kotlin.check<TransactionContext> {
+          assertEquals("my-topic", it.name)
+          assertEquals("queue.process", it.operation)
+        },
+        any(),
+      )
+  }
+
+  @Test
+  fun `intercept continues trace from headers`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val sentryTraceValue = "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1"
+    val record = createRecordWithHeaders(sentryTrace = sentryTraceValue)
+
+    interceptor.intercept(record, consumer)
+
+    verify(forkedScopes)
+      .continueTrace(org.mockito.kotlin.eq(sentryTraceValue), org.mockito.kotlin.isNull())
+  }
+
+  @Test
+  fun `intercept calls continueTrace with null when no headers`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    verify(forkedScopes).continueTrace(org.mockito.kotlin.isNull(), org.mockito.kotlin.isNull())
+  }
+
+  @Test
+  fun `intercept passes all baggage headers to continueTrace`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val sentryTraceValue = "2722d9f6ec019ade60c776169d9a8904-cedf5b7571cb4972-1"
+    val record =
+      createRecordWithHeaders(
+        sentryTrace = sentryTraceValue,
+        baggageHeaders = listOf("third=party", "sentry-sample_rate=1"),
+      )
+
+    interceptor.intercept(record, consumer)
+
+    verify(forkedScopes)
+      .continueTrace(
+        org.mockito.kotlin.eq(sentryTraceValue),
+        org.mockito.kotlin.eq(listOf("third=party", "sentry-sample_rate=1")),
+      )
+  }
+
+  @Test
+  fun `sets body size from serializedValueSize`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord(serializedValueSize = 42)
+
+    interceptor.intercept(record, consumer)
+
+    assertEquals(42, transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE))
+  }
+
+  @Test
+  fun `does not set body size when serializedValueSize is negative`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord(serializedValueSize = -1)
+
+    interceptor.intercept(record, consumer)
+
+    assertNull(transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_BODY_SIZE))
+  }
+
+  @Test
+  fun `sets retry count from delivery attempt header`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecordWithHeaders(deliveryAttempt = 3)
+
+    interceptor.intercept(record, consumer)
+
+    assertEquals(2, transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT))
+  }
+
+  @Test
+  fun `does not set retry count when delivery attempt header is missing`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    assertNull(transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_RETRY_COUNT))
+  }
+
+  @Test
+  fun `sets receive latency from enqueued time in epoch seconds`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val enqueuedTime = (System.currentTimeMillis() / 1000.0 - 1.0).toString()
+    val record = createRecordWithHeaders(enqueuedTime = enqueuedTime)
+
+    interceptor.intercept(record, consumer)
+
+    val latency = transaction.data?.get(SpanDataConvention.MESSAGING_MESSAGE_RECEIVE_LATENCY)
+    assertTrue(latency is Long && latency >= 0)
+  }
+
+  @Test
+  fun `does not create span when queue tracing is disabled`() {
+    options.isEnableQueueTracing = false
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    val result = interceptor.intercept(record, consumer)
+
+    verify(scopes, never()).forkedRootScopes(any())
+    verify(forkedScopes, never()).makeCurrent()
+    assertEquals(record, result)
+  }
+
+  @Test
+  fun `does not create span when origin is ignored`() {
+    options.setIgnoredSpanOrigins(listOf(SentryKafkaRecordInterceptor.TRACE_ORIGIN))
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    val result = interceptor.intercept(record, consumer)
+
+    verify(scopes, never()).forkedRootScopes(any())
+    verify(forkedScopes, never()).makeCurrent()
+    assertEquals(record, result)
+  }
+
+  @Test
+  fun `delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    whenever(delegate.intercept(record, consumer)).thenReturn(record)
+
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    interceptor.intercept(record, consumer)
+
+    verify(delegate).intercept(record, consumer)
+  }
+
+  @Test
+  fun `delegates to existing interceptor when consumer is null`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    whenever(delegate.intercept(record)).thenReturn(record)
+
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val result = interceptor.intercept(record)
+
+    assertEquals(record, result)
+    verify(delegate).intercept(record)
+  }
+
+  @Test
+  fun `success finishes transaction and delegates`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+    interceptor.success(record, consumer)
+
+    verify(delegate).success(record, consumer)
+  }
+
+  @Test
+  fun `failure finishes transaction with error and delegates`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+    val exception = RuntimeException("processing failed")
+
+    interceptor.intercept(record, consumer)
+    interceptor.failure(record, exception, consumer)
+
+    verify(delegate).failure(record, exception, consumer)
+  }
+
+  @Test
+  fun `afterRecord delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+
+    interceptor.afterRecord(record, consumer)
+
+    verify(delegate).afterRecord(record, consumer)
+  }
+
+  @Test
+  fun `trace origin is set correctly`() {
+    assertEquals("auto.queue.spring.kafka.consumer", SentryKafkaRecordInterceptor.TRACE_ORIGIN)
+  }
+
+  @Test
+  fun `clearThreadState cleans up stale context`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    interceptor.clearThreadState(consumer)
+
+    verify(lifecycleToken).close()
+  }
+
+  @Test
+  fun `clearThreadState is no-op when no context exists`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+
+    // should not throw
+    interceptor.clearThreadState(consumer)
+  }
+
+  @Test
+  fun `setupThreadState delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+
+    verify(delegate).setupThreadState(consumer)
+  }
+
+  @Test
+  fun `setupThreadState is no-op without delegate`() {
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+
+    // should not throw
+    interceptor.setupThreadState(consumer)
+  }
+
+  @Test
+  fun `clearThreadState delegates to existing interceptor`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.clearThreadState(consumer)
+
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `clearThreadState delegates to existing interceptor even when sentry cleanup throws`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    whenever(lifecycleToken.close()).thenThrow(RuntimeException("boom"))
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+    val record = createRecord()
+
+    interceptor.intercept(record, consumer)
+
+    try {
+      interceptor.clearThreadState(consumer)
+    } catch (ignored: RuntimeException) {
+      // expected
+    }
+
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `full lifecycle intercept success clearThreadState closes token exactly once`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    whenever(delegate.intercept(record, consumer)).thenReturn(record)
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+    interceptor.intercept(record, consumer)
+    interceptor.success(record, consumer)
+    interceptor.clearThreadState(consumer)
+
+    // token closed once by success(); clearThreadState must not re-close it
+    verify(lifecycleToken, times(1)).close()
+    assertTrue(transaction.isFinished)
+    // delegate hooks still delegated across the full lifecycle
+    verify(delegate).setupThreadState(consumer)
+    verify(delegate).success(record, consumer)
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `when delegate intercept returns null clearThreadState still finishes transaction and closes token`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    // delegate filters the record — per Spring Kafka contract, success/failure will not be invoked
+    whenever(delegate.intercept(record, consumer)).thenReturn(null)
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+    val result = interceptor.intercept(record, consumer)
+    interceptor.clearThreadState(consumer)
+
+    assertNull(result)
+    verify(lifecycleToken, times(1)).close()
+    assertTrue(transaction.isFinished)
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `when delegate intercept throws clearThreadState still finishes transaction and closes token`() {
+    val delegate = mock<RecordInterceptor<String, String>>()
+    val record = createRecord()
+    val boom = RuntimeException("delegate boom")
+    whenever(delegate.intercept(record, consumer)).thenThrow(boom)
+    val interceptor = SentryKafkaRecordInterceptor(scopes, delegate)
+
+    interceptor.setupThreadState(consumer)
+    val thrown = assertFailsWith<RuntimeException> { interceptor.intercept(record, consumer) }
+    assertEquals(boom, thrown)
+
+    interceptor.clearThreadState(consumer)
+
+    verify(lifecycleToken, times(1)).close()
+    assertTrue(transaction.isFinished)
+    verify(delegate).clearThreadState(consumer)
+  }
+
+  @Test
+  fun `intercept cleans up stale context from previous record`() {
+    val lifecycleToken2 = mock<ISentryLifecycleToken>()
+    val forkedScopes2 = mock<IScopes>()
+    whenever(forkedScopes2.options).thenReturn(options)
+    whenever(forkedScopes2.makeCurrent()).thenReturn(lifecycleToken2)
+    val tx2 = SentryTracer(TransactionContext("queue.process", "queue.process"), forkedScopes2)
+    whenever(forkedScopes2.startTransaction(any<TransactionContext>(), any())).thenReturn(tx2)
+
+    var callCount = 0
+
+    val interceptor = SentryKafkaRecordInterceptor<String, String>(scopes)
+    val record = createRecord()
+
+    whenever(scopes.forkedRootScopes(any())).thenAnswer {
+      callCount++
+      if (callCount == 1) forkedScopes else forkedScopes2
+    }
+
+    // First intercept sets up context
+    interceptor.intercept(record, consumer)
+
+    // Second intercept without success/failure — should clean up stale context first
+    interceptor.intercept(record, consumer)
+
+    // First lifecycle token should have been closed by the defensive cleanup
+    verify(lifecycleToken).close()
+  }
+}
diff --git a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/RestTestClient.kt b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/RestTestClient.kt
index da552ff93bc..b9dc0f3ccad 100644
--- a/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/RestTestClient.kt
+++ b/sentry-system-test-support/src/main/kotlin/io/sentry/systemtest/util/RestTestClient.kt
@@ -81,6 +81,12 @@ class RestTestClient(private val backendBaseUrl: String) : LoggingInsecureRestCl
     return response?.body?.string()
   }
 
+  fun produceKafkaMessage(message: String = "hello from sentry!"): String? {
+    val request = Request.Builder().url("$backendBaseUrl/kafka/produce?message=$message")
+
+    return callTyped(request, true)
+  }
+
   fun getCountMetric(): String? {
     val request = Request.Builder().url("$backendBaseUrl/metric/count")
 
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 8bd1e90e094..13dfd6b9b39 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -529,6 +529,7 @@ public final class io/sentry/ExternalOptions {
 	public fun isEnableLogs ()Ljava/lang/Boolean;
 	public fun isEnableMetrics ()Ljava/lang/Boolean;
 	public fun isEnablePrettySerializationOutput ()Ljava/lang/Boolean;
+	public fun isEnableQueueTracing ()Ljava/lang/Boolean;
 	public fun isEnableSpotlight ()Ljava/lang/Boolean;
 	public fun isEnabled ()Ljava/lang/Boolean;
 	public fun isForceInit ()Ljava/lang/Boolean;
@@ -548,6 +549,7 @@ public final class io/sentry/ExternalOptions {
 	public fun setEnableLogs (Ljava/lang/Boolean;)V
 	public fun setEnableMetrics (Ljava/lang/Boolean;)V
 	public fun setEnablePrettySerializationOutput (Ljava/lang/Boolean;)V
+	public fun setEnableQueueTracing (Ljava/lang/Boolean;)V
 	public fun setEnableSpotlight (Ljava/lang/Boolean;)V
 	public fun setEnableUncaughtExceptionHandler (Ljava/lang/Boolean;)V
 	public fun setEnabled (Ljava/lang/Boolean;)V
@@ -3714,6 +3716,7 @@ public class io/sentry/SentryOptions {
 	public fun isEnableEventSizeLimiting ()Z
 	public fun isEnableExternalConfiguration ()Z
 	public fun isEnablePrettySerializationOutput ()Z
+	public fun isEnableQueueTracing ()Z
 	public fun isEnableScopePersistence ()Z
 	public fun isEnableScreenTracking ()Z
 	public fun isEnableShutdownHook ()Z
@@ -3774,6 +3777,7 @@ public class io/sentry/SentryOptions {
 	public fun setEnableEventSizeLimiting (Z)V
 	public fun setEnableExternalConfiguration (Z)V
 	public fun setEnablePrettySerializationOutput (Z)V
+	public fun setEnableQueueTracing (Z)V
 	public fun setEnableScopePersistence (Z)V
 	public fun setEnableScreenTracking (Z)V
 	public fun setEnableShutdownHook (Z)V
@@ -4418,6 +4422,14 @@ public abstract interface class io/sentry/SpanDataConvention {
 	public static final field HTTP_RESPONSE_CONTENT_LENGTH_KEY Ljava/lang/String;
 	public static final field HTTP_START_TIMESTAMP Ljava/lang/String;
 	public static final field HTTP_STATUS_CODE_KEY Ljava/lang/String;
+	public static final field MESSAGING_DESTINATION_NAME Ljava/lang/String;
+	public static final field MESSAGING_MESSAGE_BODY_SIZE Ljava/lang/String;
+	public static final field MESSAGING_MESSAGE_ENVELOPE_SIZE Ljava/lang/String;
+	public static final field MESSAGING_MESSAGE_ID Ljava/lang/String;
+	public static final field MESSAGING_MESSAGE_RECEIVE_LATENCY Ljava/lang/String;
+	public static final field MESSAGING_MESSAGE_RETRY_COUNT Ljava/lang/String;
+	public static final field MESSAGING_OPERATION_TYPE Ljava/lang/String;
+	public static final field MESSAGING_SYSTEM Ljava/lang/String;
 	public static final field PROFILER_ID Ljava/lang/String;
 	public static final field THREAD_ID Ljava/lang/String;
 	public static final field THREAD_NAME Ljava/lang/String;
diff --git a/sentry/src/main/java/io/sentry/ExternalOptions.java b/sentry/src/main/java/io/sentry/ExternalOptions.java
index e992c04466b..4e44ea422ec 100644
--- a/sentry/src/main/java/io/sentry/ExternalOptions.java
+++ b/sentry/src/main/java/io/sentry/ExternalOptions.java
@@ -58,6 +58,7 @@ public final class ExternalOptions {
   private @Nullable Boolean enableBackpressureHandling;
   private @Nullable Boolean enableDatabaseTransactionTracing;
   private @Nullable Boolean enableCacheTracing;
+  private @Nullable Boolean enableQueueTracing;
   private @Nullable Boolean globalHubMode;
   private @Nullable Boolean forceInit;
   private @Nullable Boolean captureOpenTelemetryEvents;
@@ -168,6 +169,8 @@ public final class ExternalOptions {
 
     options.setEnableCacheTracing(propertiesProvider.getBooleanProperty("enable-cache-tracing"));
 
+    options.setEnableQueueTracing(propertiesProvider.getBooleanProperty("enable-queue-tracing"));
+
     options.setGlobalHubMode(propertiesProvider.getBooleanProperty("global-hub-mode"));
 
     options.setCaptureOpenTelemetryEvents(
@@ -541,6 +544,14 @@ public void setEnableCacheTracing(final @Nullable Boolean enableCacheTracing) {
     return enableCacheTracing;
   }
 
+  public void setEnableQueueTracing(final @Nullable Boolean enableQueueTracing) {
+    this.enableQueueTracing = enableQueueTracing;
+  }
+
+  public @Nullable Boolean isEnableQueueTracing() {
+    return enableQueueTracing;
+  }
+
   public void setGlobalHubMode(final @Nullable Boolean globalHubMode) {
     this.globalHubMode = globalHubMode;
   }
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index a6f78cfad9c..0d038482d07 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -508,6 +508,9 @@ public class SentryOptions {
   /** Whether cache operations (get, put, remove, flush) should be traced. */
   private boolean enableCacheTracing = false;
 
+  /** Whether queue operations (publish, process) should be traced. */
+  private boolean enableQueueTracing = false;
+
   /** Date provider to retrieve the current date from. */
   @ApiStatus.Internal
   private final @NotNull LazyEvaluator<SentryDateProvider> dateProvider =
@@ -2704,6 +2707,26 @@ public void setEnableCacheTracing(boolean enableCacheTracing) {
     this.enableCacheTracing = enableCacheTracing;
   }
 
+  /**
+   * Whether Sentry emits Queue spans and transforms OpenTelemetry messaging spans to match Sentry's
+   * queue conventions.
+   *
+   * @return true if queue tracing is enabled
+   */
+  public boolean isEnableQueueTracing() {
+    return enableQueueTracing;
+  }
+
+  /**
+   * Whether Sentry emits Queue spans and transforms OpenTelemetry messaging spans to match Sentry's
+   * queue conventions.
+   *
+   * @param enableQueueTracing true to enable queue tracing
+   */
+  public void setEnableQueueTracing(boolean enableQueueTracing) {
+    this.enableQueueTracing = enableQueueTracing;
+  }
+
   /**
    * Whether Sentry is enabled.
    *
@@ -3545,6 +3568,9 @@ public void merge(final @NotNull ExternalOptions options) {
     if (options.isEnableCacheTracing() != null) {
       setEnableCacheTracing(options.isEnableCacheTracing());
     }
+    if (options.isEnableQueueTracing() != null) {
+      setEnableQueueTracing(options.isEnableQueueTracing());
+    }
     if (options.getMaxRequestBodySize() != null) {
       setMaxRequestBodySize(options.getMaxRequestBodySize());
     }
diff --git a/sentry/src/main/java/io/sentry/SpanDataConvention.java b/sentry/src/main/java/io/sentry/SpanDataConvention.java
index 647c0dacddf..4ede74505cb 100644
--- a/sentry/src/main/java/io/sentry/SpanDataConvention.java
+++ b/sentry/src/main/java/io/sentry/SpanDataConvention.java
@@ -30,4 +30,12 @@ public interface SpanDataConvention {
   String CACHE_KEY = "cache.key";
   String CACHE_OPERATION = "cache.operation";
   String CACHE_WRITE = "cache.write";
+  String MESSAGING_SYSTEM = "messaging.system";
+  String MESSAGING_DESTINATION_NAME = "messaging.destination.name";
+  String MESSAGING_MESSAGE_ID = "messaging.message.id";
+  String MESSAGING_MESSAGE_RETRY_COUNT = "messaging.message.retry.count";
+  String MESSAGING_MESSAGE_BODY_SIZE = "messaging.message.body.size";
+  String MESSAGING_MESSAGE_ENVELOPE_SIZE = "messaging.message.envelope.size";
+  String MESSAGING_MESSAGE_RECEIVE_LATENCY = "messaging.message.receive.latency";
+  String MESSAGING_OPERATION_TYPE = "messaging.operation.type";
 }
diff --git a/sentry/src/main/java/io/sentry/util/SpanUtils.java b/sentry/src/main/java/io/sentry/util/SpanUtils.java
index cad4d483656..c324feed840 100644
--- a/sentry/src/main/java/io/sentry/util/SpanUtils.java
+++ b/sentry/src/main/java/io/sentry/util/SpanUtils.java
@@ -40,6 +40,10 @@ public final class SpanUtils {
       origins.add("auto.http.spring7.resttemplate");
       origins.add("auto.http.openfeign");
       origins.add("auto.http.ktor-client");
+      origins.add("auto.queue.spring_jakarta.kafka.producer");
+      origins.add("auto.queue.spring_jakarta.kafka.consumer");
+      origins.add("auto.queue.kafka.producer");
+      origins.add("auto.queue.kafka.consumer");
     }
 
     if (SentryOpenTelemetryMode.AGENT == mode) {
diff --git a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
index 54630355557..fee707d31f3 100644
--- a/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/ExternalOptionsTest.kt
@@ -345,6 +345,20 @@ class ExternalOptionsTest {
     }
   }
 
+  @Test
+  fun `creates options with enableQueueTracing set to true`() {
+    withPropertiesFile("enable-queue-tracing=true") { options ->
+      assertTrue(options.isEnableQueueTracing == true)
+    }
+  }
+
+  @Test
+  fun `creates options with enableQueueTracing set to false`() {
+    withPropertiesFile("enable-queue-tracing=false") { options ->
+      assertTrue(options.isEnableQueueTracing == false)
+    }
+  }
+
   @Test
   fun `creates options with cron defaults`() {
     withPropertiesFile(
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index e08d0ed8f72..75a24dd68df 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -708,6 +708,11 @@ class SentryOptionsTest {
     assertFalse(SentryOptions().isEnableCacheTracing)
   }
 
+  @Test
+  fun `when options are initialized, enableQueueTracing is set to false by default`() {
+    assertFalse(SentryOptions().isEnableQueueTracing)
+  }
+
   @Test
   fun `when options are initialized, metrics is enabled by default`() {
     assertTrue(SentryOptions().metrics.isEnabled)
@@ -1018,6 +1023,23 @@ class SentryOptionsTest {
     assertEquals("original", options.orgId)
   }
 
+  @Test
+  fun `merging options applies enableQueueTracing`() {
+    val externalOptions = ExternalOptions()
+    externalOptions.setEnableQueueTracing(true)
+    val options = SentryOptions()
+    options.merge(externalOptions)
+    assertTrue(options.isEnableQueueTracing)
+  }
+
+  @Test
+  fun `merging options preserves enableQueueTracing default when not set`() {
+    val externalOptions = ExternalOptions()
+    val options = SentryOptions()
+    options.merge(externalOptions)
+    assertFalse(options.isEnableQueueTracing)
+  }
+
   @Test
   fun `getEffectiveOrgId prefers explicit orgId over DSN`() {
     val options = SentryOptions()
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 8d431d5fbdf..4b1c606bc64 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -58,6 +58,7 @@ include(
     "sentry-graphql-22",
     "sentry-graphql-core",
     "sentry-jdbc",
+    "sentry-kafka",
     "sentry-opentelemetry:sentry-opentelemetry-bootstrap",
     "sentry-opentelemetry:sentry-opentelemetry-core",
     "sentry-opentelemetry:sentry-opentelemetry-agentcustomization",
diff --git a/test/system-test-runner.py b/test/system-test-runner.py
index 1250c6cbab9..784448715e9 100644
--- a/test/system-test-runner.py
+++ b/test/system-test-runner.py
@@ -42,6 +42,7 @@
 import argparse
 import requests
 import threading
+import socket
 from pathlib import Path
 from typing import Optional, List, Tuple
 from dataclasses import dataclass
@@ -65,6 +66,32 @@
     "SENTRY_ENABLE_CACHE_TRACING": "true"
 }
 
+KAFKA_CONTAINER_NAME = "sentry-java-system-test-kafka"
+KAFKA_BOOTSTRAP_SERVERS = "localhost:9092"
+KAFKA_BROKER_REQUIRED_MODULES = {
+    "sentry-samples-console",
+    "sentry-samples-spring-boot",
+    "sentry-samples-spring-boot-opentelemetry",
+    "sentry-samples-spring-boot-opentelemetry-noagent",
+    "sentry-samples-spring-boot-jakarta",
+    "sentry-samples-spring-boot-jakarta-opentelemetry",
+    "sentry-samples-spring-boot-jakarta-opentelemetry-noagent",
+    "sentry-samples-spring-boot-4",
+    "sentry-samples-spring-boot-4-opentelemetry",
+    "sentry-samples-spring-boot-4-opentelemetry-noagent",
+}
+KAFKA_PROFILE_REQUIRED_MODULES = {
+    "sentry-samples-spring-boot",
+    "sentry-samples-spring-boot-opentelemetry",
+    "sentry-samples-spring-boot-opentelemetry-noagent",
+    "sentry-samples-spring-boot-jakarta",
+    "sentry-samples-spring-boot-jakarta-opentelemetry",
+    "sentry-samples-spring-boot-jakarta-opentelemetry-noagent",
+    "sentry-samples-spring-boot-4",
+    "sentry-samples-spring-boot-4-opentelemetry",
+    "sentry-samples-spring-boot-4-opentelemetry-noagent",
+}
+
 class ServerType(Enum):
     TOMCAT = 0
     SPRING = 1
@@ -155,6 +182,7 @@ def __init__(self):
         self.mock_server = Server(name="Mock", pid_filepath="sentry-mock-server.pid")
         self.tomcat_server = Server(name="Tomcat", pid_filepath="tomcat-server.pid")
         self.spring_server = Server(name="Spring", pid_filepath="spring-server.pid")
+        self.kafka_started_by_runner = False
 
         # Load existing PIDs if available
         for server in (self.mock_server, self.tomcat_server, self.spring_server):
@@ -196,7 +224,84 @@ def kill_process(self, pid: int, name: str) -> None:
         except (OSError, ProcessLookupError):
             print(f"Process {pid} was already dead")
 
+    def module_requires_kafka(self, sample_module: str) -> bool:
+        return sample_module in KAFKA_BROKER_REQUIRED_MODULES
 
+    def module_requires_kafka_profile(self, sample_module: str) -> bool:
+        return sample_module in KAFKA_PROFILE_REQUIRED_MODULES
+
+    def wait_for_port(self, host: str, port: int, max_attempts: int = 20) -> bool:
+        for _ in range(max_attempts):
+            try:
+                with socket.create_connection((host, port), timeout=1):
+                    return True
+            except OSError:
+                time.sleep(1)
+        return False
+
+    def remove_kafka_broker_container(self) -> None:
+        subprocess.run(
+            ["docker", "rm", "-f", KAFKA_CONTAINER_NAME],
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    def start_kafka_broker(self) -> None:
+        if self.wait_for_port("localhost", 9092, max_attempts=1):
+            print("Kafka broker already running on localhost:9092, reusing it.")
+            self.kafka_started_by_runner = False
+            return
+
+        self.remove_kafka_broker_container()
+
+        print("Starting Kafka broker (Redpanda) for system tests...")
+        run_result = subprocess.run(
+            [
+                "docker",
+                "run",
+                "-d",
+                "--name",
+                KAFKA_CONTAINER_NAME,
+                "-p",
+                "9092:9092",
+                "docker.redpanda.com/redpandadata/redpanda:v24.1.9",
+                "redpanda",
+                "start",
+                "--overprovisioned",
+                "--smp",
+                "1",
+                "--memory",
+                "1G",
+                "--reserve-memory",
+                "0M",
+                "--node-id",
+                "0",
+                "--check=false",
+                "--kafka-addr",
+                "PLAINTEXT://0.0.0.0:9092",
+                "--advertise-kafka-addr",
+                "PLAINTEXT://localhost:9092",
+            ],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+
+        if run_result.returncode != 0:
+            raise RuntimeError(f"Failed to start Kafka container: {run_result.stderr}")
+
+        if not self.wait_for_port("localhost", 9092, max_attempts=30):
+            raise RuntimeError("Kafka broker did not become ready on localhost:9092")
+
+        self.kafka_started_by_runner = True
+
+    def stop_kafka_broker(self) -> None:
+        if not self.kafka_started_by_runner:
+            return
+
+        self.remove_kafka_broker_container()
+        self.kafka_started_by_runner = False
 
     def start_sentry_mock_server(self) -> None:
         """Start the Sentry mock server."""
@@ -347,6 +452,13 @@ def start_spring_server(self, sample_module: str, java_agent: str, java_agent_au
         env.update(SENTRY_ENVIRONMENT_VARIABLES)
         env["SENTRY_AUTO_INIT"] = java_agent_auto_init
 
+        if self.module_requires_kafka_profile(sample_module):
+            env["SPRING_PROFILES_ACTIVE"] = "kafka"
+            env["SENTRY_ENABLE_QUEUE_TRACING"] = "true"
+            print("Enabling Spring profile: kafka")
+        else:
+            env.pop("SPRING_PROFILES_ACTIVE", None)
+
         # Build command
         jar_path = f"sentry-samples/{sample_module}/build/libs/{sample_module}-0.0.1-SNAPSHOT.jar"
         cmd = ["java"]
@@ -564,6 +676,12 @@ def setup_test_infrastructure(self, sample_module: str, java_agent: str,
                                  java_agent_auto_init: str, build_before_run: str,
                                  server_type: Optional[ServerType]) -> int:
         """Set up test infrastructure. Returns 0 on success, error code on failure."""
+        if self.module_requires_kafka(sample_module):
+            self.start_kafka_broker()
+            os.environ["SENTRY_SAMPLE_KAFKA_BOOTSTRAP_SERVERS"] = KAFKA_BOOTSTRAP_SERVERS
+        else:
+            os.environ.pop("SENTRY_SAMPLE_KAFKA_BOOTSTRAP_SERVERS", None)
+
         # Build if requested
         if build_before_run == "1":
             print("Building before test run")
@@ -631,6 +749,8 @@ def run_single_test(self, sample_module: str, java_agent: str,
             elif server_type == ServerType.SPRING:
                 self.stop_spring_server()
             self.stop_sentry_mock_server()
+            self.stop_kafka_broker()
+            os.environ.pop("SENTRY_SAMPLE_KAFKA_BOOTSTRAP_SERVERS", None)
 
     def run_all_tests(self) -> int:
         """Run all system tests."""
@@ -961,6 +1081,8 @@ def cleanup_on_exit(self, signum, frame):
         self.stop_spring_server()
         self.stop_sentry_mock_server()
         self.stop_tomcat_server()
+        self.stop_kafka_broker()
+        os.environ.pop("SENTRY_SAMPLE_KAFKA_BOOTSTRAP_SERVERS", None)
         sys.exit(1)
 
 def main():
@@ -1159,6 +1281,8 @@ def main():
             runner.stop_spring_server()
             runner.stop_sentry_mock_server()
             runner.stop_tomcat_server()
+            runner.stop_kafka_broker()
+            os.environ.pop("SENTRY_SAMPLE_KAFKA_BOOTSTRAP_SERVERS", None)
 
 if __name__ == "__main__":
     sys.exit(main())

From d446e68d100ab9363b233ae6b98698bb13782049 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 6 May 2026 18:40:08 +0200
Subject: [PATCH 136/391] chore(codeowners): Add Nelson and Adam (#5369)

---
 .github/CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 4a3ed92029f..6e1f71a7677 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1 +1 @@
-*       @adinauer @romtsn @markushi
+*       @adinauer @romtsn @markushi @runningcode @0xadam-brown

From 7ce4e911688f63d921a37f085dba629a097d9680 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 6 May 2026 18:59:18 +0200
Subject: [PATCH 137/391] feat(replay): Capture SurfaceView content
 (experimental) (#5333)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* feat(replay): Capture SurfaceView content (experimental)

SurfaceView (used by Unity, video players, maps, and similar) renders to
a separate Surface that is composited by SurfaceFlinger outside of the
View hierarchy. PixelCopy.request(window, ...) only captures the Window
surface, so SurfaceView regions appeared as transparent/black holes in
Session Replay recordings.

When the experimental option options.sessionReplay.isCaptureSurfaceViews
is enabled, each visible SurfaceView is now captured separately via
PixelCopy.request(surfaceView, ...) and composited onto the screenshot
using PorterDuff.DST_OVER, so the SurfaceView content draws behind the
Window content (which has transparent holes where the SurfaceViews are).

Because SurfaceView redraws do not trigger ViewTreeObserver.OnDrawListener,
the recorder bypasses the contentChanged guard when SurfaceViews are
present, so subsequent frames are re-captured at the configured frame rate
instead of reusing the last screenshot.

The option defaults to false to preserve existing behavior.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* test(replay): Cover SurfaceView capture paths

Add unit tests for the new SurfaceView capture support and extract a
compositeSurfaceViewInto helper so the drawing contract can be verified
with hand-built bitmaps (Robolectric's ShadowPixelCopy cannot produce
meaningful SurfaceView pixels because there is no real GL producer).

The tests cover:
- ViewHierarchyNode.fromView returns SurfaceViewHierarchyNode vs. generic
- View.traverse collects SurfaceView nodes when a list is supplied, not
  when it is null, and skips invisible SurfaceViews
- PixelCopyStrategy leaves hasSurfaceViews false when the option is off
- PixelCopyStrategy flags hasSurfaceViews true when the option is on
- PixelCopyStrategy completes gracefully when a SurfaceView has no valid
  surface (the common Robolectric case)
- compositeSurfaceViewInto fills transparent holes behind existing window
  content via DST_OVER, and respects both window offset and scale factors

Also fixes a latent NPE in captureSurfaceViews when SurfaceHolder.surface
is null (not just invalid) — happens before the surface is created.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* formatting

* api dump

* docs(changelog): Move SurfaceView entry to Unreleased

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* feat(replay): Wire capture-surface-views option through ManifestMetadataReader

Allow enabling the experimental SurfaceView capture in Session Replay via
the manifest meta-data `io.sentry.session-replay.capture-surface-views`,
so users relying on auto-init don't need to switch to manual
SentryAndroid.init just to flip the flag.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* ref(replay): Inline captureSurfaceViewsEnabled local

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* ref(replay): Address review comments

- Drop the dedicated hasSurfaceViews flag and ScreenshotStrategy hook;
  PixelCopyStrategy now signals \"capture again next tick\" via a
  markContentChanged callback that re-arms the recorder's existing
  contentChanged gate. One source of truth instead of two booleans.
- Inline the trivial submitMaskingAndCallback helper at its single call
  site.
- Bail early in the SurfaceView PixelCopy callback if the strategy has
  been closed mid-flight, mirroring the Window-capture callback.
- Document on SentryReplayOptions.captureSurfaceViews and in CHANGELOG
  that masking granularity is at the SurfaceView level only — content
  rendered inside a SurfaceView is opaque to the View masking system.
- Simplify ViewsTest: build the test view tree inline instead of via a
  custom Activity subclass, idle the looper after setContentView.
- Drop ViewHierarchyNodeTest — its type-dispatch coverage is implicit in
  ViewsTest, which only counts non-zero results when SurfaceView
  instances are correctly mapped to SurfaceViewHierarchyNode.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* tweaks

* fix(replay): Detect window size changes on activities with configChanges

Activities that declare android:configChanges="orientation|screenSize|..."
(e.g. Unity, fullscreen video players) keep the same root view across
rotations, so onRootViewsChanged never fires and determineWindowSize was
never re-invoked. The recording bitmap stayed at the pre-rotation size,
the rotated window content rendered into wrong-dim bitmaps, and SurfaceView
captures composited at stale coordinates.

Attach an OnLayoutChangeListener to each tracked root so a same-root
resize triggers determineWindowSize. The existing size-comparison guard
(both width and height must differ) keeps IME/adjustResize relayouts
from causing spurious reconfigurations.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(replay): Avoid windowLocation race and bitmap leak in SurfaceView capture

Address two issues flagged by review:

1. windowLocation race — root.getLocationOnScreen(windowLocation) ran on the
   main thread, but compositeSurfaceViewsAndMask read windowLocation[0]/[1]
   later from the executor thread. If a new capture cycle started before the
   compositor ran, the field was overwritten and SurfaceView pixels would
   composite at the wrong offset. Snapshot into locals (windowX/windowY) at
   capture time and pass them through, matching the existing svLocation →
   capturedX/capturedY pattern.

2. Bitmap leak when isClosed in SurfaceView callback — when the strategy
   closed mid-capture, the path recycled the in-flight svBitmap but skipped
   onCaptureComplete(), so remaining never reached zero and any sibling
   bitmaps already stored in captures[] leaked until GC. Now still drive the
   completion latch on the closed path, and have the compositor's
   early-return path recycle leftover captures.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(replay): Reconfig on single-dim resizes and recycle SurfaceView bitmap on throw

Two review-bot findings:

1. determineWindowSize used && to compare new vs last-known dimensions, so
   single-dimension resizes (split-screen drag, partial multi-window
   adjustments, foldable transitions where only one dim shifts) were
   silently dropped — onWindowSizeChanged only fired when both width AND
   height differed. The new layout listener already detects single-dim
   changes with ||, but then delegated to a function that AND'd them away.
   Switch the existing checks to || so any size delta reconfigs the
   recorder, matching the listener's intent.

2. In captureSurfaceViews, if PixelCopy.request or getLocationOnScreen
   threw after svBitmap was allocated, the catch path logged the error
   but never recycled the bitmap, leaking it until GC. Track the bitmap
   in a nullable local that the catch block recycles, and clear it after
   PixelCopy.request returns successfully so ownership transfers to the
   async callback without double-recycling.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(replay): Ignore layout changes on non-latest root in WindowRecorder

rootViews is a stack of windows (dialogs, popups, IME). The recorder
binds to the topmost root, so a background activity resizing underneath
a dialog must not reconfigure the recorder — we'd otherwise allocate a
bitmap sized to the activity while still recording the dialog. The
latest root's correct dimensions are already picked up via
determineWindowSize in the onRootViewsChanged remove path when the
overlaying window dismisses.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   7 +
 .../android/core/ManifestMetadataReader.java  |  11 +
 .../core/ScreenshotEventProcessor.java        |   2 +-
 .../core/ManifestMetadataReaderTest.kt        |  25 ++
 .../android/replay/ScreenshotRecorder.kt      |   1 +
 .../sentry/android/replay/WindowRecorder.kt   |  53 +++-
 .../replay/screenshot/PixelCopyStrategy.kt    | 237 ++++++++++++++++--
 .../io/sentry/android/replay/util/Views.kt    |  10 +-
 .../replay/viewhierarchy/ViewHierarchyNode.kt |  48 ++++
 .../screenshot/PixelCopyStrategyTest.kt       | 172 +++++++++++++
 .../sentry/android/replay/util/ViewsTest.kt   |  76 ++++++
 sentry/api/sentry.api                         |   2 +
 .../java/io/sentry/SentryReplayOptions.java   |  34 +++
 13 files changed, 650 insertions(+), 28 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 244d229b994..6b0cdd51337 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,12 @@
 
 ### Features
 
+<<<<<<< rz/feat/replay-capture-surface-views
+- Session Replay: experimental support for capturing `SurfaceView` content (e.g. Unity, video players, maps) ([#5333](https://github.com/getsentry/sentry-java/pull/5333))
+  - To enable, set `options.sessionReplay.isCaptureSurfaceViews = true`
+  - Or via manifest: `<meta-data android:name="io.sentry.session-replay.capture-surface-views" android:value="true" />`
+  - **Warning:** masking granularity is at the SurfaceView level only — the SDK cannot mask individual elements rendered inside the SurfaceView (e.g. native Unity UI, map labels, video frames). Only enable for SurfaceViews whose content is safe to record.
+=======
 - Add `Sentry.feedback()` API for `show()` and `capture()` ([#5349](https://github.com/getsentry/sentry-java/pull/5349))
   - `Sentry.showUserFeedbackDialog()` is deprecated in favor of `Sentry.feedback().show()`
   - `Sentry.captureFeedback()` is deprecated in favor of `Sentry.feedback().capture()`
@@ -36,6 +42,7 @@
 - Fix shake-to-report not triggering on some devices due to high acceleration threshold ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
 - Fix feedback form retaining previous message when shown again via shake ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
 - Avoid stack overflow when deserializing large flat JSON objects ([#5361](https://github.com/getsentry/sentry-java/pull/5361))
+>>>>>>> main
 
 ### Dependencies
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 6d90bb5ca8e..7dd6f1c1488 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -120,6 +120,8 @@ final class ManifestMetadataReader {
 
   static final String REPLAYS_DEBUG = "io.sentry.session-replay.debug";
   static final String REPLAYS_SCREENSHOT_STRATEGY = "io.sentry.session-replay.screenshot-strategy";
+  static final String REPLAYS_CAPTURE_SURFACE_VIEWS =
+      "io.sentry.session-replay.capture-surface-views";
 
   static final String REPLAYS_NETWORK_DETAIL_ALLOW_URLS =
       "io.sentry.session-replay.network-detail-allow-urls";
@@ -547,6 +549,15 @@ static void applyMetadata(
           }
         }
 
+        options
+            .getSessionReplay()
+            .setCaptureSurfaceViews(
+                readBool(
+                    metadata,
+                    logger,
+                    REPLAYS_CAPTURE_SURFACE_VIEWS,
+                    options.getSessionReplay().isCaptureSurfaceViews()));
+
         // Network Details Configuration
         if (options.getSessionReplay().getNetworkDetailAllowUrls().isEmpty()) {
           final @Nullable List<String> allowUrls =
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java
index 86b13309354..bbef7846cd9 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java
@@ -201,7 +201,7 @@ private boolean isMaskingEnabled() {
 
       final ViewHierarchyNode rootNode =
           ViewHierarchyNode.Companion.fromView(rootView, null, 0, options.getScreenshot());
-      ViewsKt.traverse(rootView, rootNode, options.getScreenshot(), options.getLogger());
+      ViewsKt.traverse(rootView, rootNode, options.getScreenshot(), options.getLogger(), null);
       return rootNode;
     } catch (Throwable e) {
       options.getLogger().log(SentryLevel.ERROR, "Failed to build view hierarchy", e);
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index 81b73d5dea7..52cb085b1ee 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -2022,6 +2022,31 @@ class ManifestMetadataReaderTest {
     )
   }
 
+  @Test
+  fun `applyMetadata reads capture-surface-views to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.REPLAYS_CAPTURE_SURFACE_VIEWS to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.sessionReplay.isCaptureSurfaceViews)
+  }
+
+  @Test
+  fun `applyMetadata reads capture-surface-views and keeps default if not found`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertFalse(fixture.options.sessionReplay.isCaptureSurfaceViews)
+  }
+
   @Test
   fun `applyMetadata reads anrProfilingSampleRate to options`() {
     // Arrange
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ScreenshotRecorder.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ScreenshotRecorder.kt
index 8cc7bccede3..ce987c24ce8 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ScreenshotRecorder.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ScreenshotRecorder.kt
@@ -47,6 +47,7 @@ internal class ScreenshotRecorder(
           options,
           config,
           debugOverlayDrawable,
+          markContentChanged = { contentChanged.set(true) },
         )
     }
 
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/WindowRecorder.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/WindowRecorder.kt
index ead8e2645ab..19c61900889 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/WindowRecorder.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/WindowRecorder.kt
@@ -17,6 +17,7 @@ import io.sentry.android.replay.util.hasSize
 import io.sentry.android.replay.util.removeOnPreDrawListenerSafe
 import io.sentry.util.AutoClosableReentrantLock
 import java.lang.ref.WeakReference
+import java.util.WeakHashMap
 import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.atomic.AtomicBoolean
 
@@ -33,6 +34,7 @@ internal class WindowRecorder(
   private val isRecording = AtomicBoolean(false)
   private val rootViews = ArrayList<WeakReference<View>>()
   private var lastKnownWindowSize: Point = Point()
+  private val rootLayoutListeners = WeakHashMap<View, View.OnLayoutChangeListener>()
   private val rootViewsLock = AutoClosableReentrantLock()
   private val capturerLock = AutoClosableReentrantLock()
   private val backgroundProcessingHandlerLock = AutoClosableReentrantLock()
@@ -124,7 +126,9 @@ internal class WindowRecorder(
         rootViews.add(WeakReference(root))
         capturer?.recorder?.bind(root)
         determineWindowSize(root)
+        attachLayoutListener(root)
       } else {
+        detachLayoutListener(root)
         capturer?.recorder?.unbind(root)
         rootViews.removeAll { it.get() == root }
 
@@ -132,6 +136,7 @@ internal class WindowRecorder(
         if (newRoot != null && root != newRoot) {
           capturer?.recorder?.bind(newRoot)
           determineWindowSize(newRoot)
+          attachLayoutListener(newRoot)
         } else {
           Unit // synchronized block wants us to return something lol
         }
@@ -139,9 +144,45 @@ internal class WindowRecorder(
     }
   }
 
+  /**
+   * Activities that handle their own configuration changes (e.g. Unity, video players via
+   * `android:configChanges="orientation|screenSize|..."`) keep the same root view across rotations,
+   * so [onRootViewsChanged] never fires and [determineWindowSize] would never re-detect the new
+   * dimensions. Watch the root for layout-time size changes to catch these cases.
+   */
+  private fun attachLayoutListener(root: View) {
+    if (rootLayoutListeners.containsKey(root)) return
+    val listener =
+      View.OnLayoutChangeListener {
+        v,
+        left,
+        top,
+        right,
+        bottom,
+        oldLeft,
+        oldTop,
+        oldRight,
+        oldBottom ->
+        val width = right - left
+        val height = bottom - top
+        val oldWidth = oldRight - oldLeft
+        val oldHeight = oldBottom - oldTop
+        if (width == oldWidth && height == oldHeight) return@OnLayoutChangeListener
+        // ignore non-latest roots so a dialog stays sized for itself, not its background activity.
+        if (v != rootViews.lastOrNull()?.get()) return@OnLayoutChangeListener
+        determineWindowSize(v)
+      }
+    rootLayoutListeners[root] = listener
+    root.addOnLayoutChangeListener(listener)
+  }
+
+  private fun detachLayoutListener(root: View) {
+    rootLayoutListeners.remove(root)?.let { root.removeOnLayoutChangeListener(it) }
+  }
+
   fun determineWindowSize(root: View) {
     if (root.hasSize()) {
-      if (root.width != lastKnownWindowSize.x && root.height != lastKnownWindowSize.y) {
+      if (root.width != lastKnownWindowSize.x || root.height != lastKnownWindowSize.y) {
         lastKnownWindowSize.set(root.width, root.height)
         windowCallback.onWindowSizeChanged(root.width, root.height)
       }
@@ -157,7 +198,7 @@ internal class WindowRecorder(
             }
             if (root.hasSize()) {
               root.removeOnPreDrawListenerSafe(this)
-              if (root.width != lastKnownWindowSize.x && root.height != lastKnownWindowSize.y) {
+              if (root.width != lastKnownWindowSize.x || root.height != lastKnownWindowSize.y) {
                 lastKnownWindowSize.set(root.width, root.height)
                 windowCallback.onWindowSizeChanged(root.width, root.height)
               }
@@ -222,7 +263,13 @@ internal class WindowRecorder(
   override fun reset() {
     lastKnownWindowSize.set(0, 0)
     rootViewsLock.acquire().use {
-      rootViews.forEach { capturer?.recorder?.unbind(it.get()) }
+      rootViews.forEach {
+        val root = it.get()
+        if (root != null) {
+          detachLayoutListener(root)
+          capturer?.recorder?.unbind(root)
+        }
+      }
       rootViews.clear()
     }
   }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
index ec3f36647c3..81dd7c5cee5 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
@@ -2,7 +2,13 @@ package io.sentry.android.replay.screenshot
 
 import android.annotation.SuppressLint
 import android.graphics.Bitmap
+import android.graphics.Canvas
 import android.graphics.Matrix
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import android.graphics.Rect
+import android.graphics.RectF
 import android.view.PixelCopy
 import android.view.View
 import io.sentry.SentryLevel.DEBUG
@@ -19,6 +25,7 @@ import io.sentry.android.replay.util.ReplayRunnable
 import io.sentry.android.replay.util.traverse
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
 import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicInteger
 import kotlin.LazyThreadSafetyMode.NONE
 
 @SuppressLint("UseKtx")
@@ -28,6 +35,9 @@ internal class PixelCopyStrategy(
   private val options: SentryOptions,
   private val config: ScreenshotRecorderConfig,
   private val debugOverlayDrawable: DebugOverlayDrawable,
+  // Lets the strategy re-arm the recorder's contentChanged gate so frames keep being captured
+  // when SurfaceViews are present (their redraws don't trigger ViewTreeObserver.OnDrawListener).
+  private val markContentChanged: () -> Unit = {},
 ) : ScreenshotStrategy {
 
   private val executor = executorProvider.getExecutor()
@@ -40,6 +50,15 @@ internal class PixelCopyStrategy(
   private val maskRenderer = MaskRenderer()
   private val contentChanged = AtomicBoolean(false)
   private val isClosed = AtomicBoolean(false)
+  private val dstOverPaint by
+    lazy(NONE) { Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OVER) } }
+  private val screenshotCanvas by lazy(NONE) { Canvas(screenshot) }
+  private val tmpSrcRect = Rect()
+  private val tmpDstRect = RectF()
+  private val windowLocation = IntArray(2)
+  private val svLocation = IntArray(2)
+
+  private class SurfaceViewCapture(val bitmap: Bitmap, val x: Int, val y: Int)
 
   @SuppressLint("NewApi")
   override fun capture(root: View) {
@@ -81,31 +100,26 @@ internal class PixelCopyStrategy(
 
           // TODO: disableAllMasking here and dont traverse?
           val viewHierarchy = ViewHierarchyNode.fromView(root, null, 0, options.sessionReplay)
-          root.traverse(viewHierarchy, options.sessionReplay, options.logger)
-
-          executor.submit(
-            ReplayRunnable("screenshot_recorder.mask") {
-              if (isClosed.get() || screenshot.isRecycled) {
-                options.logger.log(DEBUG, "PixelCopyStrategy is closed, skipping masking")
-                return@ReplayRunnable
-              }
-
-              val debugMasks = maskRenderer.renderMasks(screenshot, viewHierarchy, prescaledMatrix)
+          val surfaceViewNodes =
+            if (options.sessionReplay.isCaptureSurfaceViews) {
+              mutableListOf<ViewHierarchyNode.SurfaceViewHierarchyNode>()
+            } else {
+              null
+            }
+          root.traverse(viewHierarchy, options.sessionReplay, options.logger, surfaceViewNodes)
 
-              if (options.replayController.isDebugMaskingOverlayEnabled()) {
-                mainLooperHandler.post {
-                  if (debugOverlayDrawable.callback == null) {
-                    root.overlay.add(debugOverlayDrawable)
-                  }
-                  debugOverlayDrawable.updateMasks(debugMasks)
-                  root.postInvalidate()
-                }
+          if (surfaceViewNodes.isNullOrEmpty()) {
+            executor.submit(
+              ReplayRunnable("screenshot_recorder.mask") {
+                applyMaskingAndNotify(root, viewHierarchy)
               }
-              screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
-              lastCaptureSuccessful.set(true)
-              contentChanged.set(false)
-            }
-          )
+            )
+          } else {
+            // Re-arm the recorder's contentChanged gate; SurfaceView redraws don't trigger
+            // ViewTreeObserver.OnDrawListener, so we'd otherwise emit the same frame forever.
+            markContentChanged()
+            captureSurfaceViews(root, surfaceViewNodes, viewHierarchy)
+          }
         },
         mainLooperHandler.handler,
       )
@@ -115,6 +129,148 @@ internal class PixelCopyStrategy(
     }
   }
 
+  private fun applyMaskingAndNotify(root: View, viewHierarchy: ViewHierarchyNode) {
+    if (isClosed.get() || screenshot.isRecycled) {
+      options.logger.log(DEBUG, "PixelCopyStrategy is closed, skipping masking")
+      return
+    }
+
+    val debugMasks = maskRenderer.renderMasks(screenshot, viewHierarchy, prescaledMatrix)
+
+    if (options.replayController.isDebugMaskingOverlayEnabled()) {
+      mainLooperHandler.post {
+        if (debugOverlayDrawable.callback == null) {
+          root.overlay.add(debugOverlayDrawable)
+        }
+        debugOverlayDrawable.updateMasks(debugMasks)
+        root.postInvalidate()
+      }
+    }
+    screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
+    lastCaptureSuccessful.set(true)
+    contentChanged.set(false)
+  }
+
+  @SuppressLint("NewApi")
+  private fun captureSurfaceViews(
+    root: View,
+    surfaceViewNodes: List<ViewHierarchyNode.SurfaceViewHierarchyNode>,
+    viewHierarchy: ViewHierarchyNode,
+  ) {
+    // Snapshot the window location into locals so the executor-side compositor reads stable
+    // values even if a new capture cycle starts and overwrites the field.
+    root.getLocationOnScreen(windowLocation)
+    val windowX = windowLocation[0]
+    val windowY = windowLocation[1]
+
+    val captures = arrayOfNulls<SurfaceViewCapture>(surfaceViewNodes.size)
+    val remaining = AtomicInteger(surfaceViewNodes.size)
+
+    fun onCaptureComplete() {
+      if (remaining.decrementAndGet() == 0) {
+        compositeSurfaceViewsAndMask(root, captures, viewHierarchy, windowX, windowY)
+      }
+    }
+
+    for ((index, node) in surfaceViewNodes.withIndex()) {
+      val surfaceView = node.surfaceViewRef.get()
+      // holder.surface can be null before the surface is created — guard against NPE.
+      val surface = surfaceView?.holder?.surface
+      if (surfaceView == null || surface == null || !surface.isValid) {
+        onCaptureComplete()
+        continue
+      }
+
+      var svBitmap: Bitmap? = null
+      try {
+        svBitmap =
+          Bitmap.createBitmap(surfaceView.width, surfaceView.height, Bitmap.Config.ARGB_8888)
+        val bitmapToCapture = svBitmap
+
+        surfaceView.getLocationOnScreen(svLocation)
+        val capturedX = svLocation[0]
+        val capturedY = svLocation[1]
+
+        PixelCopy.request(
+          surfaceView,
+          bitmapToCapture,
+          { copyResult: Int ->
+            if (isClosed.get()) {
+              bitmapToCapture.recycle()
+              // still drive the completion latch so any prior captures get recycled by the
+              // composite step's early-return path.
+              onCaptureComplete()
+              return@request
+            }
+            if (copyResult == PixelCopy.SUCCESS) {
+              captures[index] = SurfaceViewCapture(bitmapToCapture, capturedX, capturedY)
+            } else {
+              bitmapToCapture.recycle()
+              options.logger.log(INFO, "Failed to capture SurfaceView: %d", copyResult)
+            }
+            onCaptureComplete()
+          },
+          mainLooperHandler.handler,
+        )
+        // Ownership transferred to the PixelCopy callback — clear local so catch doesn't
+        // double-recycle if the recycle paths above already ran.
+        svBitmap = null
+      } catch (e: Throwable) {
+        options.logger.log(WARNING, "Failed to capture SurfaceView", e)
+        svBitmap?.recycle()
+        onCaptureComplete()
+      }
+    }
+  }
+
+  private fun compositeSurfaceViewsAndMask(
+    root: View,
+    captures: Array<SurfaceViewCapture?>,
+    viewHierarchy: ViewHierarchyNode,
+    windowX: Int,
+    windowY: Int,
+  ) {
+    executor.submit(
+      ReplayRunnable("screenshot_recorder.composite") {
+        if (isClosed.get() || screenshot.isRecycled) {
+          options.logger.log(DEBUG, "PixelCopyStrategy is closed, skipping compositing")
+          recycleCaptures(captures)
+          return@ReplayRunnable
+        }
+
+        for (capture in captures) {
+          if (capture == null) continue
+          if (capture.bitmap.isRecycled) continue
+
+          compositeSurfaceViewInto(
+            screenshotCanvas,
+            dstOverPaint,
+            tmpSrcRect,
+            tmpDstRect,
+            capture.bitmap,
+            capture.x,
+            capture.y,
+            windowX,
+            windowY,
+            config.scaleFactorX,
+            config.scaleFactorY,
+          )
+          capture.bitmap.recycle()
+        }
+
+        applyMaskingAndNotify(root, viewHierarchy)
+      }
+    )
+  }
+
+  private fun recycleCaptures(captures: Array<SurfaceViewCapture?>) {
+    for (capture in captures) {
+      if (capture != null && !capture.bitmap.isRecycled) {
+        capture.bitmap.recycle()
+      }
+    }
+  }
+
   override fun onContentChanged() {
     contentChanged.set(true)
   }
@@ -148,3 +304,38 @@ internal class PixelCopyStrategy(
     )
   }
 }
+
+/**
+ * Composites [sourceBitmap] (a SurfaceView capture) onto [destCanvas] (wrapping the recording
+ * screenshot) using [destPaint] (expected to have DST_OVER xfermode), so the SurfaceView content
+ * draws _behind_ existing Window content — filling the transparent holes the Window PixelCopy
+ * leaves where SurfaceViews are.
+ *
+ * Extracted for testability — the compositing is pure drawing logic that can be driven with
+ * hand-built bitmaps, while the surrounding [PixelCopyStrategy.captureSurfaceViews] flow depends on
+ * a real SurfaceView producer that Robolectric cannot provide.
+ */
+internal fun compositeSurfaceViewInto(
+  destCanvas: Canvas,
+  destPaint: Paint,
+  tmpSrc: Rect,
+  tmpDst: RectF,
+  sourceBitmap: Bitmap,
+  sourceX: Int,
+  sourceY: Int,
+  windowX: Int,
+  windowY: Int,
+  scaleFactorX: Float,
+  scaleFactorY: Float,
+) {
+  val left = (sourceX - windowX) * scaleFactorX
+  val top = (sourceY - windowY) * scaleFactorY
+  tmpSrc.set(0, 0, sourceBitmap.width, sourceBitmap.height)
+  tmpDst.set(
+    left,
+    top,
+    left + sourceBitmap.width * scaleFactorX,
+    top + sourceBitmap.height * scaleFactorY,
+  )
+  destCanvas.drawBitmap(sourceBitmap, tmpSrc, tmpDst, destPaint)
+}
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt
index d0583cdaa6a..cacd2b1c217 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Views.kt
@@ -38,6 +38,7 @@ internal fun View.traverse(
   parentNode: ViewHierarchyNode,
   options: SentryMaskingOptions,
   logger: ILogger,
+  surfaceViewNodes: MutableList<ViewHierarchyNode.SurfaceViewHierarchyNode>? = null,
 ) {
   if (this !is ViewGroup) {
     return
@@ -59,7 +60,14 @@ internal fun View.traverse(
     if (child != null) {
       val childNode = ViewHierarchyNode.fromView(child, parentNode, indexOfChild(child), options)
       childNodes.add(childNode)
-      child.traverse(childNode, options, logger)
+      if (
+        surfaceViewNodes != null &&
+          childNode is ViewHierarchyNode.SurfaceViewHierarchyNode &&
+          childNode.isVisible
+      ) {
+        surfaceViewNodes.add(childNode)
+      }
+      child.traverse(childNode, options, logger, surfaceViewNodes)
     }
   }
   parentNode.children = childNodes
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ViewHierarchyNode.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ViewHierarchyNode.kt
index f54fa79da10..e55ba659a8e 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ViewHierarchyNode.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ViewHierarchyNode.kt
@@ -3,6 +3,7 @@ package io.sentry.android.replay.viewhierarchy
 import android.annotation.SuppressLint
 import android.annotation.TargetApi
 import android.graphics.Rect
+import android.view.SurfaceView
 import android.view.View
 import android.view.ViewParent
 import android.widget.ImageView
@@ -15,6 +16,7 @@ import io.sentry.android.replay.util.isMaskable
 import io.sentry.android.replay.util.isVisibleToUser
 import io.sentry.android.replay.util.toOpaque
 import io.sentry.android.replay.util.totalPaddingTopSafe
+import java.lang.ref.WeakReference
 
 @SuppressLint("UseRequiresApi")
 @TargetApi(26)
@@ -121,6 +123,34 @@ internal sealed class ViewHierarchyNode(
       visibleRect,
     )
 
+  class SurfaceViewHierarchyNode(
+    val surfaceViewRef: WeakReference<SurfaceView>,
+    x: Float,
+    y: Float,
+    width: Int,
+    height: Int,
+    elevation: Float,
+    distance: Int,
+    parent: ViewHierarchyNode? = null,
+    shouldMask: Boolean = false,
+    isImportantForContentCapture: Boolean = false,
+    isVisible: Boolean = false,
+    visibleRect: Rect? = null,
+  ) :
+    ViewHierarchyNode(
+      x,
+      y,
+      width,
+      height,
+      elevation,
+      distance,
+      parent,
+      shouldMask,
+      isImportantForContentCapture,
+      isVisible,
+      visibleRect,
+    )
+
   /**
    * Basically replicating this:
    * https://developer.android.com/reference/android/view/View#isImportantForContentCapture() but
@@ -379,6 +409,24 @@ internal sealed class ViewHierarchyNode(
             visibleRect = visibleRect,
           )
         }
+
+        is SurfaceView -> {
+          parent?.setImportantForCaptureToAncestors(true)
+          return SurfaceViewHierarchyNode(
+            surfaceViewRef = WeakReference(view),
+            x = view.x,
+            y = view.y,
+            width = view.width,
+            height = view.height,
+            elevation = (parent?.elevation ?: 0f) + view.elevation,
+            distance = distance,
+            parent = parent,
+            shouldMask = shouldMask,
+            isImportantForContentCapture = true,
+            isVisible = isVisible,
+            visibleRect = visibleRect,
+          )
+        }
       }
 
       return GenericViewHierarchyNode(
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
index 29a3089e686..277ad941a14 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
@@ -1,9 +1,19 @@
 package io.sentry.android.replay.screenshot
 
 import android.app.Activity
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
+import android.graphics.Rect
+import android.graphics.RectF
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.view.SurfaceView
+import android.widget.FrameLayout
 import android.widget.LinearLayout
 import android.widget.LinearLayout.LayoutParams
 import android.widget.TextView
@@ -15,21 +25,27 @@ import io.sentry.android.replay.ScreenshotRecorderConfig
 import io.sentry.android.replay.util.DebugOverlayDrawable
 import io.sentry.android.replay.util.MainLooperHandler
 import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicReference
 import kotlin.test.BeforeTest
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
 import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 import org.robolectric.Robolectric.buildActivity
 import org.robolectric.Shadows.shadowOf
 import org.robolectric.annotation.Config
+import org.robolectric.annotation.GraphicsMode
 import org.robolectric.shadows.ShadowPixelCopy
 
 @Config(shadows = [ShadowPixelCopy::class], sdk = [30])
+@GraphicsMode(GraphicsMode.Mode.NATIVE)
 @RunWith(AndroidJUnit4::class)
 class PixelCopyStrategyTest {
 
@@ -38,6 +54,7 @@ class PixelCopyStrategyTest {
     val callback = mock<ScreenshotRecorderCallback>()
     val debugOverlayDrawable = mock<DebugOverlayDrawable>()
     val config = ScreenshotRecorderConfig(100, 100, 1f, 1f, 1, 1000)
+    val contentChangedMarked = AtomicBoolean(false)
 
     fun getSut(executor: ScheduledExecutorService = mock()): PixelCopyStrategy {
       return PixelCopyStrategy(
@@ -52,8 +69,21 @@ class PixelCopyStrategyTest {
         options,
         config,
         debugOverlayDrawable,
+        markContentChanged = { contentChangedMarked.set(true) },
       )
     }
+
+    /** Executor mock that runs submitted tasks synchronously on the calling thread. */
+    fun inlineExecutor(): ScheduledExecutorService {
+      return mock {
+        doAnswer {
+            (it.arguments[0] as Runnable).run()
+            null // submit(Runnable) returns Future<?>; returning Unit breaks the cast
+          }
+          .whenever(mock)
+          .submit(any<Runnable>())
+      }
+    }
   }
 
   private val fixture = Fixture()
@@ -101,6 +131,125 @@ class PixelCopyStrategyTest {
 
     if (failure.get() != null) throw failure.get()
   }
+
+  @Test
+  fun `capture does not call markContentChanged when option is disabled`() {
+    val activity = buildActivity(ActivityWithSurfaceView::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    // Default: isCaptureSurfaceViews = false
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    strategy.capture(activity.get().findViewById(android.R.id.content))
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertFalse(fixture.contentChangedMarked.get())
+    assertTrue(strategy.lastCaptureSuccessful())
+    verify(fixture.callback).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  fun `capture re-arms contentChanged when option is enabled and SurfaceView is present`() {
+    val activity = buildActivity(ActivityWithSurfaceView::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    fixture.options.sessionReplay.isCaptureSurfaceViews = true
+
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    strategy.capture(activity.get().findViewById(android.R.id.content))
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertTrue(fixture.contentChangedMarked.get())
+  }
+
+  @Test
+  fun `capture completes when SurfaceView surface is not valid`() {
+    // In Robolectric the SurfaceView holder surface is not valid — this exercises the
+    // `surfaceView.holder.surface.isValid == false` branch: each SurfaceView skips its
+    // PixelCopy and onCaptureComplete still fires, eventually running the compositor and
+    // callback.
+    val activity = buildActivity(ActivityWithSurfaceView::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    fixture.options.sessionReplay.isCaptureSurfaceViews = true
+
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    strategy.capture(activity.get().findViewById(android.R.id.content))
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertTrue(strategy.lastCaptureSuccessful())
+    verify(fixture.callback).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  fun `compositeSurfaceViewInto draws source behind existing destination with DST_OVER`() {
+    // Destination ("Window capture"): 100x100, opaque red in the top half,
+    // fully transparent in the bottom half (the "hole" where the SurfaceView sits).
+    val dest = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888)
+    val destCanvas = Canvas(dest)
+    destCanvas.drawColor(Color.RED)
+    val clearPaint = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.CLEAR) }
+    destCanvas.drawRect(0f, 50f, 100f, 100f, clearPaint)
+
+    // Source ("SurfaceView capture"): 100x50, solid blue — matches the hole.
+    val source = Bitmap.createBitmap(100, 50, Bitmap.Config.ARGB_8888)
+    source.eraseColor(Color.BLUE)
+
+    val dstOverPaint = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OVER) }
+    compositeSurfaceViewInto(
+      destCanvas = destCanvas,
+      destPaint = dstOverPaint,
+      tmpSrc = Rect(),
+      tmpDst = RectF(),
+      sourceBitmap = source,
+      sourceX = 0,
+      sourceY = 50,
+      windowX = 0,
+      windowY = 0,
+      scaleFactorX = 1f,
+      scaleFactorY = 1f,
+    )
+
+    // Top region: still red (DST_OVER must not overwrite existing opaque pixels).
+    assertEquals(Color.RED, dest.getPixel(50, 10))
+    assertEquals(Color.RED, dest.getPixel(50, 49))
+    // Bottom region: now blue (source filled the transparent hole).
+    assertEquals(Color.BLUE, dest.getPixel(50, 50))
+    assertEquals(Color.BLUE, dest.getPixel(99, 99))
+  }
+
+  @Test
+  fun `compositeSurfaceViewInto respects scale factors and window offset`() {
+    // Destination is 50x50 (scaled recording), fully transparent.
+    val dest = Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888)
+    val destCanvas = Canvas(dest)
+
+    // Source is 40x40, solid green; its on-screen location is (20, 20).
+    val source = Bitmap.createBitmap(40, 40, Bitmap.Config.ARGB_8888)
+    source.eraseColor(Color.GREEN)
+
+    val dstOverPaint = Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OVER) }
+    compositeSurfaceViewInto(
+      destCanvas = destCanvas,
+      destPaint = dstOverPaint,
+      tmpSrc = Rect(),
+      tmpDst = RectF(),
+      sourceBitmap = source,
+      sourceX = 20,
+      sourceY = 20,
+      windowX = 10, // window is at (10, 10)
+      windowY = 10,
+      scaleFactorX = 0.5f, // 0.5x scale → destination coords halve
+      scaleFactorY = 0.5f,
+    )
+
+    // Expected destination rect: ((20-10)*0.5, (20-10)*0.5) = (5, 5), size 40*0.5 = 20x20
+    // → occupies pixels [5..25) × [5..25). Check inside, on the edge, and just outside.
+    assertEquals(Color.GREEN, dest.getPixel(5, 5))
+    assertEquals(Color.GREEN, dest.getPixel(15, 15))
+    assertEquals(Color.GREEN, dest.getPixel(24, 24))
+    // Just outside the rect — still transparent.
+    assertEquals(0, dest.getPixel(4, 4))
+    assertEquals(0, dest.getPixel(25, 25))
+  }
 }
 
 private class SimpleActivity : Activity() {
@@ -123,3 +272,26 @@ private class SimpleActivity : Activity() {
     setContentView(linearLayout)
   }
 }
+
+private class ActivityWithSurfaceView : Activity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    val root =
+      FrameLayout(this).apply {
+        setBackgroundColor(android.R.color.white)
+        layoutParams =
+          FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.MATCH_PARENT,
+          )
+      }
+    root.addView(
+      TextView(this).apply {
+        text = "Overlay"
+        layoutParams = FrameLayout.LayoutParams(200, 50)
+      }
+    )
+    root.addView(SurfaceView(this).apply { layoutParams = FrameLayout.LayoutParams(200, 200) })
+    setContentView(root)
+  }
+}
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ViewsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ViewsTest.kt
index 530c124af4f..2eaa8411cfe 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ViewsTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ViewsTest.kt
@@ -1,15 +1,36 @@
 package io.sentry.android.replay.util
 
+import android.app.Activity
+import android.os.Looper
+import android.view.SurfaceView
 import android.view.View
+import android.widget.FrameLayout
+import android.widget.FrameLayout.LayoutParams
+import android.widget.TextView
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.NoOpLogger
+import io.sentry.SentryReplayOptions
+import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode
+import kotlin.test.BeforeTest
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
+import org.robolectric.Robolectric.buildActivity
+import org.robolectric.Shadows.shadowOf
 
 @RunWith(AndroidJUnit4::class)
 class ViewsTest {
+
+  @BeforeTest
+  fun setup() {
+    // Required so Robolectric reports the activity window as visible; otherwise
+    // View.isVisibleToUser() returns false and SurfaceView nodes are skipped.
+    System.setProperty("robolectric.areWindowsMarkedVisible", "true")
+  }
+
   @Test
   fun `hasSize returns true for positive values`() {
     val view = View(ApplicationProvider.getApplicationContext())
@@ -33,4 +54,59 @@ class ViewsTest {
     view.bottom = -1
     assertFalse(view.hasSize())
   }
+
+  @Test
+  fun `traverse collects visible SurfaceView nodes when a list is supplied`() {
+    val (root, _) = buildSurfaceViewHierarchy()
+    val rootNode = ViewHierarchyNode.fromView(root, null, 0, SentryReplayOptions(false, null))
+    val collected = mutableListOf<ViewHierarchyNode.SurfaceViewHierarchyNode>()
+
+    root.traverse(rootNode, SentryReplayOptions(false, null), NoOpLogger.getInstance(), collected)
+
+    assertEquals(2, collected.size)
+  }
+
+  @Test
+  fun `traverse does not collect SurfaceView nodes when list parameter is null`() {
+    val (root, _) = buildSurfaceViewHierarchy()
+    val rootNode = ViewHierarchyNode.fromView(root, null, 0, SentryReplayOptions(false, null))
+
+    root.traverse(rootNode, SentryReplayOptions(false, null), NoOpLogger.getInstance(), null)
+  }
+
+  @Test
+  fun `traverse skips invisible SurfaceViews`() {
+    val (root, surfaceViews) = buildSurfaceViewHierarchy()
+    surfaceViews.first().visibility = View.GONE
+
+    val rootNode = ViewHierarchyNode.fromView(root, null, 0, SentryReplayOptions(false, null))
+    val collected = mutableListOf<ViewHierarchyNode.SurfaceViewHierarchyNode>()
+
+    root.traverse(rootNode, SentryReplayOptions(false, null), NoOpLogger.getInstance(), collected)
+
+    assertEquals(1, collected.size)
+  }
+
+  /**
+   * Builds and attaches a small view tree: `FrameLayout(SurfaceView, TextView, FrameLayout(
+   * SurfaceView))`. Returns the root [FrameLayout] and the two [SurfaceView]s in tree order so
+   * tests can mutate visibility without re-walking the hierarchy.
+   */
+  private fun buildSurfaceViewHierarchy(): Pair<FrameLayout, List<SurfaceView>> {
+    val activity = buildActivity(Activity::class.java).setup().get()
+    val sv1 = SurfaceView(activity).apply { layoutParams = LayoutParams(100, 100) }
+    val sv2 = SurfaceView(activity).apply { layoutParams = LayoutParams(50, 50) }
+    val nested = FrameLayout(activity).apply { addView(sv2) }
+    val root =
+      FrameLayout(activity).apply {
+        layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        addView(sv1)
+        addView(TextView(activity).apply { text = "label" })
+        addView(nested)
+      }
+    activity.setContentView(root)
+    // Flush the layout/attach pass so isAttachedToWindow / visibility computations are accurate.
+    shadowOf(Looper.getMainLooper()).idle()
+    return root to listOf(sv1, sv2)
+  }
 }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 13dfd6b9b39..a433abbb37c 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -4069,12 +4069,14 @@ public final class io/sentry/SentryReplayOptions : io/sentry/SentryMaskingOption
 	public fun getSessionDuration ()J
 	public fun getSessionSampleRate ()Ljava/lang/Double;
 	public fun getSessionSegmentDuration ()J
+	public fun isCaptureSurfaceViews ()Z
 	public fun isDebug ()Z
 	public fun isNetworkCaptureBodies ()Z
 	public fun isSessionReplayEnabled ()Z
 	public fun isSessionReplayForErrorsEnabled ()Z
 	public fun isTrackConfiguration ()Z
 	public fun setBeforeErrorSampling (Lio/sentry/SentryReplayOptions$BeforeErrorSamplingCallback;)V
+	public fun setCaptureSurfaceViews (Z)V
 	public fun setDebug (Z)V
 	public fun setMaskAllImages (Z)V
 	public fun setMaskAllText (Z)V
diff --git a/sentry/src/main/java/io/sentry/SentryReplayOptions.java b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
index d4e0fd257cd..6eb4a58e1c2 100644
--- a/sentry/src/main/java/io/sentry/SentryReplayOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
@@ -146,6 +146,20 @@ public enum SentryReplayQuality {
   @ApiStatus.Experimental
   private @NotNull ScreenshotStrategyType screenshotStrategy = ScreenshotStrategyType.PIXEL_COPY;
 
+  /**
+   * Whether to capture SurfaceView content (e.g. Unity, video players, maps) during replay
+   * recording. When enabled, each SurfaceView in the view hierarchy will be captured separately via
+   * PixelCopy and composited onto the screenshot. Only applies when {@link #screenshotStrategy} is
+   * {@link ScreenshotStrategyType#PIXEL_COPY}. Default is disabled.
+   *
+   * <p><b>Warning:</b> the SDK cannot mask individual elements rendered inside a SurfaceView (e.g.
+   * native Unity UI, map labels, video frames) — masking granularity is at the SurfaceView level
+   * only. If the SurfaceView is configured to be masked, the entire region is redacted; otherwise
+   * its full pixel content is sent in the replay. Only enable this for SurfaceViews whose content
+   * is safe to record.
+   */
+  @ApiStatus.Experimental private boolean captureSurfaceViews = false;
+
   /**
    * Capture request and response details for XHR and fetch requests that match the given URLs.
    * Default is empty (network details not collected).
@@ -383,6 +397,26 @@ public void setScreenshotStrategy(final @NotNull ScreenshotStrategyType screensh
     this.screenshotStrategy = screenshotStrategy;
   }
 
+  /**
+   * Whether SurfaceView capture is enabled. See {@link #captureSurfaceViews}.
+   *
+   * @return true if SurfaceView capture is enabled
+   */
+  @ApiStatus.Experimental
+  public boolean isCaptureSurfaceViews() {
+    return captureSurfaceViews;
+  }
+
+  /**
+   * Enables or disables SurfaceView capture. See {@link #captureSurfaceViews}.
+   *
+   * @param captureSurfaceViews true to enable SurfaceView capture
+   */
+  @ApiStatus.Experimental
+  public void setCaptureSurfaceViews(final boolean captureSurfaceViews) {
+    this.captureSurfaceViews = captureSurfaceViews;
+  }
+
   /**
    * Gets the list of URLs for which network request and response details should be captured.
    *

From 566492415f8cb9a2596b13798f4088f3d5b7f614 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Wed, 6 May 2026 22:12:40 +0200
Subject: [PATCH 138/391] Fix Changelog (#5381)

Fix faultly changelog

#skip-changelog
---
 CHANGELOG.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6b0cdd51337..fba1451f4ae 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,12 +4,10 @@
 
 ### Features
 
-<<<<<<< rz/feat/replay-capture-surface-views
 - Session Replay: experimental support for capturing `SurfaceView` content (e.g. Unity, video players, maps) ([#5333](https://github.com/getsentry/sentry-java/pull/5333))
   - To enable, set `options.sessionReplay.isCaptureSurfaceViews = true`
   - Or via manifest: `<meta-data android:name="io.sentry.session-replay.capture-surface-views" android:value="true" />`
   - **Warning:** masking granularity is at the SurfaceView level only — the SDK cannot mask individual elements rendered inside the SurfaceView (e.g. native Unity UI, map labels, video frames). Only enable for SurfaceViews whose content is safe to record.
-=======
 - Add `Sentry.feedback()` API for `show()` and `capture()` ([#5349](https://github.com/getsentry/sentry-java/pull/5349))
   - `Sentry.showUserFeedbackDialog()` is deprecated in favor of `Sentry.feedback().show()`
   - `Sentry.captureFeedback()` is deprecated in favor of `Sentry.feedback().capture()`
@@ -42,7 +40,6 @@
 - Fix shake-to-report not triggering on some devices due to high acceleration threshold ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
 - Fix feedback form retaining previous message when shown again via shake ([#5366](https://github.com/getsentry/sentry-java/pull/5366))
 - Avoid stack overflow when deserializing large flat JSON objects ([#5361](https://github.com/getsentry/sentry-java/pull/5361))
->>>>>>> main
 
 ### Dependencies
 

From 6219eb3d898ce527b1024eaa75e6a3ee5e985601 Mon Sep 17 00:00:00 2001
From: romtsn <4999776+romtsn@users.noreply.github.com>
Date: Wed, 6 May 2026 20:20:52 +0000
Subject: [PATCH 139/391] release: 8.41.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fba1451f4ae..681753db082 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.41.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 38ad043eee8..81fdf72ff04 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.40.0
+versionName=8.41.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From eb95dedf76a910ecab60a3764126936bedf0d505 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 7 May 2026 09:18:41 +0200
Subject: [PATCH 140/391] Upload screenshot snapshots to Sentry (#5378)

* feat(android-core): Upload screenshot snapshots to Sentry

Replace local golden-image comparison in ScreenshotEventProcessorTest
with Sentry Snapshots for visual diffing. Screenshots are now generated
to build/test-snapshots/ and uploaded via sentry-cli in CI.

- Remove local snapshot comparison logic and dropbox-differ dependency
- Delete golden images from version control
- Add sentry-cli install and upload steps to build.yml
- Use PR head SHA checkout for correct base-vs-head diffing

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(ci): Use correct Sentry org and project for snapshot upload

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/workflows/build.yml                   |  13 ++++
 gradle/libs.versions.toml                     |   2 +-
 sentry-android-core/build.gradle.kts          |   2 +-
 .../core/ScreenshotEventProcessorTest.kt      |  57 +-----------------
 .../screenshot_mask_all.png                   | Bin 2608 -> 0 bytes
 .../screenshot_mask_custom_view.png           | Bin 14948 -> 0 bytes
 ...eenshot_mask_ellipsized_compose_masked.png | Bin 2917 -> 0 bytes
 ...nshot_mask_ellipsized_compose_unmasked.png | Bin 20367 -> 0 bytes
 ...screenshot_mask_ellipsized_view_masked.png | Bin 2331 -> 0 bytes
 ...reenshot_mask_ellipsized_view_unmasked.png | Bin 16750 -> 0 bytes
 .../screenshot_mask_images.png                | Bin 9353 -> 0 bytes
 .../screenshot_mask_text.png                  | Bin 8366 -> 0 bytes
 .../screenshot_multiline_compose_masked.png   | Bin 3272 -> 0 bytes
 .../screenshot_multiline_compose_unmasked.png | Bin 28628 -> 0 bytes
 .../screenshot_multiline_view_masked.png      | Bin 2924 -> 0 bytes
 .../screenshot_multiline_view_unmasked.png    | Bin 20865 -> 0 bytes
 .../screenshot_no_masking.png                 | Bin 14845 -> 0 bytes
 17 files changed, 17 insertions(+), 57 deletions(-)
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_all.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_custom_view.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_masked.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_unmasked.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_masked.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_unmasked.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_images.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_text.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_masked.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_unmasked.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_masked.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_unmasked.png
 delete mode 100644 sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_no_masking.png

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 089913c9727..b16444183f5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -21,6 +21,7 @@ jobs:
       - name: Checkout Repo
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
         with:
+          ref: ${{ github.event.pull_request.head.sha || github.sha }}
           submodules: 'recursive'
 
       - name: Setup Java Version
@@ -44,6 +45,18 @@ jobs:
       - name: Run Tests with coverage and Lint
         run: make preMerge
 
+      - name: Install Sentry CLI
+        run: curl -sL https://sentry.io/get-cli/ | bash
+
+      - name: Upload Snapshots to Sentry
+        run: |
+          sentry-cli build snapshots ./sentry-android-core/build/test-snapshots \
+            --app-id sentry-android-core
+        env:
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+          SENTRY_ORG: sentry-sdks
+          SENTRY_PROJECT: sentry-android
+
       - name: Upload coverage to Codecov
         uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # pin@v4
         with:
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 50d415c212a..8b7cbee3700 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -247,4 +247,4 @@ msgpack = { module = "org.msgpack:msgpack-core", version = "0.9.8" }
 okhttp-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version.ref = "okhttp" }
 okio = { module = "com.squareup.okio:okio", version = "1.13.0" }
 roboelectric = { module = "org.robolectric:robolectric", version = "4.14" }
-dropbox-differ = { module = "com.dropbox.differ:differ-jvm", version = "0.3.0" }
+
diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index ffd42c7d4d7..f61cec89265 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -108,7 +108,7 @@ dependencies {
   testImplementation(projects.sentryAndroidReplay)
   testImplementation(projects.sentryCompose)
   testImplementation(projects.sentryAndroidNdk)
-  testImplementation(libs.dropbox.differ)
+
   testImplementation(libs.androidx.activity.compose)
   testImplementation(libs.androidx.compose.ui)
   testImplementation(libs.androidx.compose.foundation)
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt
index 300936153f7..b8e223f08e9 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ScreenshotEventProcessorTest.kt
@@ -2,8 +2,6 @@ package io.sentry.android.core
 
 import android.app.Activity
 import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
 import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.drawable.Drawable
@@ -31,9 +29,6 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.unit.sp
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import com.dropbox.differ.Color as DifferColor
-import com.dropbox.differ.Image
-import com.dropbox.differ.SimpleImageComparator
 import io.sentry.Attachment
 import io.sentry.Hint
 import io.sentry.MainEventProcessor
@@ -66,17 +61,8 @@ import org.robolectric.shadows.ShadowPixelCopy
 class ScreenshotEventProcessorTest {
 
   companion object {
-    /**
-     * Set to `true` to record/update golden images for snapshot tests. When `true`, screenshots
-     * will be saved to src/test/resources/snapshots/{testName}.png. Set back to `false` after
-     * recording to run comparison tests.
-     */
-    private const val RECORD_SNAPSHOTS = false
-
     private val SNAPSHOTS_DIR =
-      File("src/test/resources/snapshots/ScreenshotEventProcessorTest").also {
-        if (RECORD_SNAPSHOTS) it.mkdirs()
-      }
+      File("build/test-snapshots/ScreenshotEventProcessorTest").also { it.mkdirs() }
   }
 
   private class Fixture {
@@ -507,17 +493,6 @@ class ScreenshotEventProcessorTest {
 
   private fun getEvent(): SentryEvent = SentryEvent(Throwable("Throwable"))
 
-  /**
-   * Helper method for snapshot testing. Processes an event and captures a screenshot, then either
-   * saves it as a golden image (when RECORD_SNAPSHOTS=true) or compares it against an existing
-   * golden image.
-   *
-   * @param testName The name used for the golden image file (without extension)
-   * @param attachScreenshot Whether to enable screenshot attachment
-   * @param isReplayAvailable Whether the replay module is available (enables masking)
-   * @param configureOptions Lambda to configure additional options before processing
-   * @return The captured screenshot bytes, or null if no screenshot was captured
-   */
   private fun processEventForSnapshots(
     testName: String,
     attachScreenshot: Boolean = true,
@@ -536,38 +511,10 @@ class ScreenshotEventProcessorTest {
     val screenshot = hint.screenshot ?: return null
     val bytes = screenshot.bytes ?: screenshot.byteProvider?.call() ?: return null
 
-    val snapshotFile = File(SNAPSHOTS_DIR, "$testName.png")
-    if (RECORD_SNAPSHOTS) {
-      snapshotFile.writeBytes(bytes)
-      println("Recorded snapshot: ${snapshotFile.absolutePath}")
-    } else if (snapshotFile.exists()) {
-      val expectedBitmap = BitmapFactory.decodeFile(snapshotFile.absolutePath)
-      val actualBitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
-
-      val result =
-        SimpleImageComparator(maxDistance = 0.01f)
-          .compare(BitmapImage(expectedBitmap), BitmapImage(actualBitmap))
-      assertEquals(
-        0,
-        result.pixelDifferences,
-        "Screenshot does not match golden image: ${snapshotFile.absolutePath}. " +
-          "Pixel differences: ${result.pixelDifferences}",
-      )
-    }
+    File(SNAPSHOTS_DIR, "$testName.png").writeBytes(bytes)
 
     return bytes
   }
-
-  /** Adapter to wrap Android Bitmap for use with dropbox/differ library */
-  private class BitmapImage(private val bitmap: Bitmap) : Image {
-    override val height: Int
-      get() = bitmap.height
-
-    override val width: Int
-      get() = bitmap.width
-
-    override fun getPixel(x: Int, y: Int): DifferColor = DifferColor(bitmap.getPixel(x, y))
-  }
 }
 
 private class CustomView(context: Context) : View(context) {
diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_all.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_all.png
deleted file mode 100644
index aa1ec41ee06c2a1dbbd7292cf8629935c5c9b634..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2608
zcmeHJSx}Q#6#jqy6oLgwt%ig^g42<XN`rA>%_faSY5~U;WG$hA4od`N69_5FfCW*9
zQ4mz>Sgi|$6h;yUBrFm{1gZ#xKnQ_}tOAiG34zc*ee*%9Qy+Zjow;-8+~v&qzVqF4
z@0tDH9_DMT)&Kxt?zxw7002Nb+<TD5@QiWA{&{!+;}3Ya1H2CFao9k_yL%o&!YvIM
zmIDB$QcuS2L&;ZO$w)r_M<K2PdeRu2LovRSyLEfwlfQ1}m9-X^UfgBVMGD-q>tM^?
zAMY@}n-ZPBz`h-|No&+F6f&zLe>K#m_+G6Hkf)wgi!qjvZA3;t1W3>zq7s36ypC?W
z5BSCYtwxy#EpEip5?u`Pss#eULpg<0ALrX>QWlBZI1mA3SqRH(%oO55Xgw|D%jwEZ
z#7w{sXZl+of$y2ry?zJXcCrWDse?GDYa(*7w&yo->6ZW_KO<zA>AQ@CNg!qp^5V)8
zETc&fqSA34y^0=EFnxD3i%ahj8%3azQH_Dsk4$br>c&&6A@dcc8)qr~<kaQsAVSy~
zfB@eIn*lZ6#>OUn4mTqgiAJsuIQW!OWs4{-A!=r9Y%EvFpHS$~q|>tb=FNOfddZ4W
z&CeU?Cfe>Pf`p=DItwe>IGM8HE!)oDXCHwMT?TorG&70Ko9Kjg=b9U)B}sJXupxLo
z#(R=yI96E<x(X{;tM${`;q{W;`sl^ar*5tKqZZ<oEp-fwMEOM!A^C}C1pO;pZ;-k$
zc9*SRYV%3jl^>~{EX@#55Fy!V@w;E>&~-3NeA8gWY+d$Dq&spzJVB|?MvF-Jmqowm
zn)aY<BQx@{DFr7VGfk@7%utV|@+|BN;<9<YYzLf!_Ylk5W%R)-k*gIMdf6f-CfZVO
zJT!e7H1g9i$y3-D-{Rf)fd(SCa4ll(7Emo_1B6r$4-d=W3{`J1M=JK^d1<&_8WvDE
z?T^f|ko>+CLh{=_KoV~UiZ9n?_C-0`6|_2&$<_s}VR<BR8kG<p9?qnep6lxBI%_ty
zqEqAgI*2Jt^W)XofSXcE$aT5u-7+`YdGuM$Q+T&%Rj+fV(L~R<r)N$+LdDD+1Ibh>
zUbM2<k74FDhmxpinr&3hvhde|6RtKs*T`7f>hfIjvPK0j3)u2}*o-f4$dR99pkhXA
zz-2OLX7C}7Jy`o-KHOsMTCqx{N?x4mgLl*P8s_qfTHb4wqmkty8`}d@z6f)@${SWs
zbl=-L;v~kDQq!&Alh}%&hgQtI*todux4OoYOg3_y!sQL^f!KOWhoC%?zC>FdA3HKX
zf1);39Rq`g(XdHmE@AXJ(7~!wX;dSB`r6mI&FL-~0)#QZ6cx3z3iVg8X8dmojgO~H
zEGe3@anYKtKYZ@>29544Dw*>^#JqeC;PLo;l2`+~IO|lG_A1UFP`BO$0|q<dx^!A<
z#y=BhJQUoreUQ-CUW^f>uEuDk%4%S`U>}s6nCK|RjI<Vf?KG%)eZMVQ#S~(#3~q^X
zQAs;%WN0Yll{vxMx-2H+!9+U4#K92FEDR)pAcuL9;;1n7a3bx|xo68!5a07?5F%w|
zX#plLyz^RM%8t2SR#o3b%8=5L7m7}fU$hw*xCoMIwBYiw*RPdrFk^Ab@!5uk24@!+
ztV3{}HFH^jX-r_>h_$Wgq@L>cOLZyJrqvx=8wo3fBrf{F?w*o=Y4S5()w-vn<nH5?
zVH1I%C-b&LP_1U#t39_lw3f57bi`@D!x=>(!@_Y=3I-InvzV?|^P8HQ4x3r#Haoky
z;YLSCiOGP4SPIvO4frhRzu(S9B9WLld{B|bBJzoF-G1k*@WI#l<9drUROitCQ-H+y
o6OZ)c;{M;;r>)EP&rjJZSjl6n5Eo>4_}2$`?(t^u+(R<|28Xc1xBvhE

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_custom_view.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_custom_view.png
deleted file mode 100644
index 217c73490cec235b4b9a07fb87fcc4c371a5f406..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14948
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

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_masked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_masked.png
deleted file mode 100644
index 53e5a236c3e86ca447dd8674c6d046302bd8cda1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2917
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
EZ)r_j+5i9m

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_unmasked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_compose_unmasked.png
deleted file mode 100644
index efc2304c4f2db20dc4d7d5ee73a741da009a9001..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 20367
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

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_masked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_masked.png
deleted file mode 100644
index 1530d58fd9af3df79b8339c8b953b12c4df77535..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2331
zcmeAS@N?(olHy`uVBq!ia0y~yU~~ZDYaDDq5w`UKUw{;2age(c!@6@aFM%AEVkgfK
z4j`!ENa<i;;5h2(;uumf=j~m?yxUPs4uORersVCJs-k@&Y11->IM1#vnkhRy-|{Zu
zoM6_v{D**naF4o*YuBWAmTP?`78QQ<u(RXaefM1|yTF(AYxx-xw3#?kI29(SHaJXU
zV2Z@e$-nmJ({yp}vkd?58}QtITfO~IQN$s3pRKMO;=Bt!FfO-B=Mdk`rcrl5=-f>q
zbH|1?u1pzU*mYjU_!=^?Z1Uq<a8Z6kTk)2o90DhV92C468g&?1HnHI2SXnki@4LXV
zBldYlx1hp=tsV@$OpU5@S8KX8I9y9&G~r^IR&Z`wg`rh};JSZDU(^dZJ;>i?QypX4
zz%c!cuK-bY0G;x>S9NuRmNIc}LU;P>vp4K*Wcb$Cef#(Kw<{mpgM2x8`TxJn-{0FS
z{WW$m^N;-;@&$Rv-}P`lynluZ7*5gAN-dMuGj_=rc=}~dnyuh)?FECKy}k5bM)AzN
z*>3C~UcSt{#>b#{^@Gu;vo8)Ctf|#uP`A7%AZg8e%oMvD-Pj8{r;0ONGg=-93YjGg
zQmjnVGxBElFf^_?2?{2?lbXJ>wkmxoY@c?VY1^iolYZ38H3%?0-}EH%#fzsK81j07
z?!XrNz4JI~Eo9>Uo^i=Y&@EQ8>#x;)=IP(WA-`c;a{9H1_JlBoR(^}^rcM?=r55~P
zjE>smnAgM*3H0`#KRI96V_KF*nOHUW`}=pl5qJ>P6UUb=(YCdpHDS{AypEo^Y>%a|
zr@O_>JC1qrFcjDR{q^<9djlqxb(anwK78`NVW#Dp<Hz04Gc(Wr{psoHcR=vuy=A6j
zNQ3U3`}g%f*-rLvjOAw8wk4%Gt(T#n{XvO@#q{n-q5mEnja%1NUbC#S)M<!Lmg2#h
z+83)k$@8^`+Zzi?Mckgkc`-S@yYkXxg+uIfPH!}yZO^S!b0BOQ&%-C#4UgDknpC5n
zsBug%)ogI9KcH&4)zhuvK<MwkzrVl9b=Pk<<vILjF2kCa=cSdBmmid1WD0-(`}_ON
z+k_n+y!!j&WAe2!CXSfB{qpwbZuuc+gzOTA>ow-;2V&;i*WUwrKKt4>u(@AeUViuR
zVdAxIlcycN_5S;AetEkyw*(Jd`u6+pyXWWU?*@X%+x}b&jz4VhHsU$_?%%(<Z{Hw+
zp?6S77aaG;fpLE>_p|E9{uTj?>89uGfbL{1$o6Sw#Fh)Qzqq_O{P4r8^zAl+w-(nI
z)E?U>_IZiAW1eM=`|<l4Ed|wStQ!RO*>fu1nRoI!L-)tu{$KC&Z$ARecG*D;y><T{
z{%6>J5SZ7cWE~dI`~U1e<Ms2{bN-r(jCbCD&z3uWb)yDT%>IjvGHr=xA2V3&_FR6z
z&G!F~Z*Om3YiH0oV0u9E-oD!1Ulkd+XUH7*rLp1P?}yXQL<#<qXuQ<KaEN{T^Cjg?
zB2F4L1-sj(1HoE;rUY(KYQ$ZnjmqFF@JB;uG<2|43dA%P2&J8``C;6mtsRF7rGO0_
N22WQ%mvv4FO#mO{7J~o)

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_unmasked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_ellipsized_view_unmasked.png
deleted file mode 100644
index 57b4bfa8f42f9b911ce06a8d5835799d472b4c58..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 16750
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
Joz=bjzW@p0?Kc1b

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_images.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_images.png
deleted file mode 100644
index bd4378a9947ef6999486f1371bee3e56f596157c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 9353
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

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_text.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_mask_text.png
deleted file mode 100644
index 6ffbe1e07f5ec41580bf25ba1b5c317b608ae804..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8366
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

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_masked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_masked.png
deleted file mode 100644
index fb8f816218d0610b70c51cf01fc4a13ada281590..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3272
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

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_unmasked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_compose_unmasked.png
deleted file mode 100644
index dc4beee80a68507a82bce68ebd330f48314fabe5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 28628
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

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_masked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_masked.png
deleted file mode 100644
index 373752de30f95ef642b961822be5ddcdbdeb9cba..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2924
zcmeHJc~nzZ9)5WV5Y}W6F%4T_1W^!BSu_fSUBqZaR0t5+oU)XovdSKi5u_|~T8ITR
zU>OW3OIQSKSOQ3K#7KY;c7dV=jFcq^fwIhtwdb_VbWTtInm>BadFOZT@4b7!d%ySl
zzI$(z&N#@+U}XRRkas+3>kI%e0`%~al2AsnlC%s3Sg5muHBj+Vbr$L%LaiNLkWh<7
z`lSMZtg@r6mCKELb7M_sR7TWOCa?RQ%B%e+(Mmp&Kr^`18i(td1{;tMU34XgcZ`%s
z1e+X%{b{zc&lpFm{T%kCd@^z*=&NyIt@pf}|J4>Z;rrE+fV==Wdd6l}0{BvkO3;TP
ze57$`Cm_)kL_Sp{;Bo=53V}}5{?)4~i|sdkrB+AS+h*8|=W483Z`Irdm}d@hk_^|4
zWk0+nH#uAZOVeN~*wj5GqH%mO=)Wpe)<+^%!4W>?ssxs0A<Cw<Lt*E{{{vG`iurm^
z9xy+E4*oESHZ>xVjhF9NI!?gxhe7{6$g=i32NyeL2)j+UKJVGqNoKpB`iJ=nmO#yW
zA`SlLUUov3Rb^iw9DpYMuRGuQ^?&fiZ<s?-JUuss-7BlB1JxKWAyMaxUMK&Rl@;=)
zhXB|zY?Imu=KmdQEy^thA+p>}HIwO;5LsM14(Hk~L~1{tibA0-&{Rt<mCyOBu>}Hw
z#Q@Bxp{MqZSy7gKQS$)U7-}<y4)_t19`xb2ND9~2$<flX2sGx!=4RZiwmzERWyE5!
zifK#&kk}e4B3%l3OO{`#*xcG=Eh{S5DtK|`g|PQ3S)CjXhd6shp9x1uE-o$g#;z}y
zE+1A7lPUDXG1KXE`u8GH!`jAL=xnjRYk)eApu%7<E;JMQYf6I#=oz2GU%7nJ^1v-b
z>geZQ<-63WOQzm6wY~e9XfR<Ud4W?FD^J>>Mr{XLXLx(ysclkWhsM*%J`KE3>UUCQ
zU+3NuIqxk@#gcpXQ%&?SH!LB}@~5Y#eL7bUsFHa02<{K4nf9R}x6qgv_t%3FRKht2
z2M5m7lyA1LERHnV+G>?OCG(4NEi4fVg+84tbR6MaWMm|#ukU=e?+6UEQ&U$r-M4R_
zUFKK-_J!Z!MS?NYlt!a*3M>=y=H}+KI?WU{bbU+@Y)^G&arpd;*(UnoGWtpE1Azh0
zdg14$6JU%EwtL|1S110unD~l^X^OJ{4&GFHU2aR9u;LBML!p(&M~Qp=yuVyc0;<xV
zO8E@Iz?+Y**!)^PAX4s!E}CI6jcZIy0Vp0G%TE-jt&bHZZZs}UV5ko<w^4ErACwwF
z5I0N9HN>H$O63FKp=jag5H*pfe$!S@g8LFRoF7L?W~w_$kVIZl)~*ozeRM(b5?*3q
zpz?BDIo#_S9TdG63^em$+3&!vKsC08W&8)Yj0b(Qwf(3}`?yL8pC_8tl$e;9^7xlW
z^>-BhV}(MN3peZPcykWLTK_mf_uY@H^TjlD*U4DjnWd%bfHhqMb0ZX52Ag3|Ijs9E
zGKrvR;q>O<WB9$zlu*3fnDk}yi+BlTYyY#Nw|&tVkR3C12(ts^qve!qBsYKa&H8jf
z6dHTCbTV<i?s8gfZ$9piN`^nhOrMjyXu^}vuFGm|kQ6(bmr-S9<ws$Rj*rtQZ6FLG
zS;Jzve^gKkDqNdU(GScI&yTk_8G2g@0RD!B2B~H7#wgUjq<jk=CwQR^4GlSrvjwLN
zeXSV4umspOI5ZTHnU$5_U0_M0JWtB`9tPH4kB%n48S$f^O`HQ04RpS6%vlV|(~hLp
zAo=)7nC{hGrcQcvP*!uHo`@WO@q7U2K;2!f)Zt;iEryJgut&%#(Z1zmE~OhUuEbPB
zJ20)}zBV0nZBI&E^-V}<iHeUmh={FhgV_b!0&`nbi+gmsNqv32U1qQpQYkzvjCaDq
zLit!70CuRUswy3;_@$kv;Vmr<BR(6K29?4iBL_~Ho9{kWr-mc(CMUf^LqeQi57HmB
zp4QogvV{kQMnw&6tO*%IuU;91#6nfB^|zuW%lM7K&w_(@yR|zr*jh-jp!Lns;ahvI
zk>whTb7we56g6gu89n)*?zQ0NV>>6hp#;V@W6TH&r-L`e!G)-{sDl)j6E0T`XVgG8
zb=hIE?1|>sHRot)VqX|?qNBsEKmcGMC(Z2CLuJBB(y~SD!oWNk-@O(_cZb)#p^%DY
zK>-3RGV7+xV@}Q;I%%ADhS68NJ=x<=4@yMp#lCi}DUN{rs4G7%KAGA0(#+~9ir@Ze
z=?RF+D!c@D+?7eOIDZ9_ZxvaJJMO|o6_kg(gHA>D<XbWxo}M|BHdb|g{lMF4aq_1H
zUlah**(&RkH5W3~#GZ5?$7-pDMsv?kG*!Wqt>0}u7vhZNPK(}ZQjO4)kFtOY_BNL}
z<N=+DKMMeU1LAoaZ<;AcV6L4`mh=h7OVkP0Dj}cBrGQMy3YdX+P|%}gMXJe+Dtp<}
zYkeLy|1W2hb+^_XW1N*}V$*GwcqbVxqtSS|Xf_Ogun9?397Vu>2G~LE?>z7S9Q7wr
hzjYV<Kd23XB_eFG_wLsP1<;KdaI`yPTVd^$^lu8NTM_^O

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_unmasked.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_multiline_view_unmasked.png
deleted file mode 100644
index df051c63713c9b9d8cb2d85f9fd3adfae3eed7fa..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 20865
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
b!SZ?X^rEP%{zTCDL=a^Kb@@VBlc)b1?Z&sE

diff --git a/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_no_masking.png b/sentry-android-core/src/test/resources/snapshots/ScreenshotEventProcessorTest/screenshot_no_masking.png
deleted file mode 100644
index edf883f9a4b2e02ae1474341e7ac01264aab81f3..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14845
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
PPCPAjJ+(>|+ZX>0n>sh_


From 648fbf7377201213bb9afdc500d24c862c7fbc10 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 8 May 2026 14:18:33 +0200
Subject: [PATCH 141/391] chore: Add Dependabot (#5380)

* chore(deps): Add Dependabot for Gradle plugins

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore(deps): Exclude Spring Boot from Dependabot

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore(deps): Add commit message prefix for Dependabot

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore(deps): Set dependabot to weekly and add dependency grouping

Switch both gradle and github-actions ecosystems from daily to weekly.
Group related dependencies so they're updated together in single PRs
(androidx, compose, kotlin, spring, opentelemetry, graphql, jackson,
and all github-actions).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fixup: Remove gradle dependency groups, keep only gh-actions group

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore(deps): Add gradle dependency groups for androidx, compose, kotlin, jackson

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore(deps): Set dependabot to daily and reorder compose group

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/dependabot.yml | 39 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 38 insertions(+), 1 deletion(-)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index b88a67a7f0c..10325576354 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,6 +1,43 @@
 version: 2
+registries:
+  gradle-plugin-portal:
+    type: maven-repository
+    url: https://plugins.gradle.org/m2
+    username: dummy # Required by dependabot
+    password: dummy # Required by dependabot
 updates:
+  - package-ecosystem: "gradle"
+    directory: "/"
+    registries:
+      - gradle-plugin-portal
+    schedule:
+      interval: "daily"
+    ignore:
+      - dependency-name: "org.springframework.boot*"
+    commit-message:
+      prefix: "chore(deps)"
+    groups:
+      compose:
+        patterns:
+          - "androidx.compose*"
+          - "org.jetbrains.compose*"
+      androidx:
+        patterns:
+          - "androidx.*"
+      kotlin:
+        patterns:
+          - "org.jetbrains.kotlin*"
+          - "org.jetbrains.kotlinx*"
+      jackson:
+        patterns:
+          - "com.fasterxml.jackson*"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: weekly
+      interval: "daily"
+    commit-message:
+      prefix: "chore(deps)"
+    groups:
+      github-actions:
+        patterns:
+          - "*"

From ae06e700a1ace0e5063d0dced160f25f2757bedb Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 11 May 2026 09:15:05 +0200
Subject: [PATCH 142/391] fix(android): Declare test-snapshots as task output
 for cache compatibility (#5396)

* fix(android): Declare test-snapshots as task output for cache compatibility

The screenshot snapshot PNGs written by ScreenshotEventProcessorTest are
not declared as outputs of testDebugUnitTest. When the task result comes
from the Gradle remote cache, the test code never runs and the directory
is never created, so sentry-cli finds an empty folder and uploads nothing.

Declaring the directory as a task output ensures Gradle caches and
restores the snapshots on cache hits.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Format code

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 sentry-android-core/build.gradle.kts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index f61cec89265..abcca4f8833 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -70,6 +70,13 @@ tasks.withType<JavaCompile>().configureEach {
   }
 }
 
+// Snapshot PNGs are written by ScreenshotEventProcessorTest at runtime but must be declared as
+// outputs so Gradle's build cache restores them on cache hits (otherwise the CLI upload step
+// finds an empty directory).
+tasks
+  .matching { it.name == "testDebugUnitTest" || it.name == "testReleaseUnitTest" }
+  .configureEach { outputs.dir(layout.buildDirectory.dir("test-snapshots")) }
+
 dependencies {
   api(projects.sentry)
   compileOnly(libs.jetbrains.annotations)

From f829d5acb53476f24789dacba5cbfe4d0b2d0b7f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 11 May 2026 10:42:48 +0200
Subject: [PATCH 143/391] chore(deps): bump the github-actions group across 1
 directory with 5 updates (#5395)

Bumps the github-actions group with 5 updates in the / directory:

| Package | From | To |
| --- | --- | --- |
| [phoenix-actions/test-reporting](https://github.com/phoenix-actions/test-reporting) | `15` | `16` |
| [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) | `2.26.2` | `2.26.3` |
| [github/codeql-action](https://github.com/github/codeql-action) | `4.35.2` | `4.35.4` |
| [saucelabs/saucectl-run-action](https://github.com/saucelabs/saucectl-run-action) | `4.3.0` | `4.4.0` |
| [getsentry/craft](https://github.com/getsentry/craft) | `2.26.2` | `2.26.3` |



Updates `phoenix-actions/test-reporting` from 15 to 16
- [Release notes](https://github.com/phoenix-actions/test-reporting/releases)
- [Changelog](https://github.com/phoenix-actions/test-reporting/blob/main/CHANGELOG.md)
- [Commits](https://github.com/phoenix-actions/test-reporting/compare/f957cd93fc2d848d556fa0d03c57bc79127b6b5e...7317eea6e13c47348dd0bb318669485157c518d6)

Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.26.2 to 2.26.3
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/3dc647fee3586e57c7c31eb900fdec7cbb44f23f...bae212ca7aec50bb716eafd387c80bcfb28da937)

Updates `github/codeql-action` from 4.35.2 to 4.35.4
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/95e58e9a2cdfd71adc6e0353d5c52f41a045d225...68bde559dea0fdcac2102bfdf6230c5f70eb485e)

Updates `saucelabs/saucectl-run-action` from 4.3.0 to 4.4.0
- [Release notes](https://github.com/saucelabs/saucectl-run-action/releases)
- [Commits](https://github.com/saucelabs/saucectl-run-action/compare/39e4f0666ca8ecb4b60847213c6e0fbd6a0c2bd8...bc81720eb01738d9c664b07fe42621bd0014283f)

Updates `getsentry/craft` from 2.26.2 to 2.26.3
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/3dc647fee3586e57c7c31eb900fdec7cbb44f23f...bae212ca7aec50bb716eafd387c80bcfb28da937)

---
updated-dependencies:
- dependency-name: getsentry/craft
  dependency-version: 2.26.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.26.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action
  dependency-version: 4.35.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: phoenix-actions/test-reporting
  dependency-version: '16'
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
- dependency-name: saucelabs/saucectl-run-action
  dependency-version: 4.4.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                   | 2 +-
 .github/workflows/build.yml                        | 2 +-
 .github/workflows/changelog-preview.yml            | 2 +-
 .github/workflows/codeql-analysis.yml              | 4 ++--
 .github/workflows/integration-tests-benchmarks.yml | 4 ++--
 .github/workflows/integration-tests-ui.yml         | 2 +-
 .github/workflows/release.yml                      | 2 +-
 .github/workflows/spring-boot-2-matrix.yml         | 2 +-
 .github/workflows/spring-boot-3-matrix.yml         | 2 +-
 .github/workflows/spring-boot-4-matrix.yml         | 2 +-
 .github/workflows/system-tests-backend.yml         | 2 +-
 11 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 33ba8ae93e8..df0b0ebca3c 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -103,7 +103,7 @@ jobs:
             **/build/outputs/mapping/release/*
 
       - name: Test Report
-        uses: phoenix-actions/test-reporting@f957cd93fc2d848d556fa0d03c57bc79127b6b5e # pin@v15
+        uses: phoenix-actions/test-reporting@7317eea6e13c47348dd0bb318669485157c518d6 # pin@v16
         if: always()
         with:
           name: JUnit AGP ${{ matrix.agp }} - Integrations ${{ matrix.integrations }}
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index b16444183f5..f5e89b2be40 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -73,7 +73,7 @@ jobs:
             **/build/reports/*
 
       - name: Test Report
-        uses: phoenix-actions/test-reporting@f957cd93fc2d848d556fa0d03c57bc79127b6b5e # pin@v15
+        uses: phoenix-actions/test-reporting@7317eea6e13c47348dd0bb318669485157c518d6 # pin@v16
         if: always()
         with:
           name: JUnit Build
diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index 64e68738b2e..4d5a78a4114 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@3dc647fee3586e57c7c31eb900fdec7cbb44f23f # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@bae212ca7aec50bb716eafd387c80bcfb28da937 # v2
     secrets: inherit
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index acb0483b5ba..ae8d78d305e 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # pin@v2
+        uses: github/codeql-action/init@68bde559dea0fdcac2102bfdf6230c5f70eb485e # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@95e58e9a2cdfd71adc6e0353d5c52f41a045d225 # pin@v2
+        uses: github/codeql-action/analyze@68bde559dea0fdcac2102bfdf6230c5f70eb485e # pin@v2
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index b5457751809..2f5a63f747a 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -48,7 +48,7 @@ jobs:
         run: make assembleBenchmarks
 
       - name: Run All Tests in SauceLab
-        uses: saucelabs/saucectl-run-action@39e4f0666ca8ecb4b60847213c6e0fbd6a0c2bd8 # pin@v3
+        uses: saucelabs/saucectl-run-action@bc81720eb01738d9c664b07fe42621bd0014283f # pin@v3
         if: github.event_name != 'pull_request' && env.SAUCE_USERNAME != null
         env:
           GITHUB_TOKEN: ${{ github.token }}
@@ -58,7 +58,7 @@ jobs:
           config-file: .sauce/sentry-uitest-android-benchmark.yml
 
       - name: Run one test in SauceLab
-        uses: saucelabs/saucectl-run-action@39e4f0666ca8ecb4b60847213c6e0fbd6a0c2bd8 # pin@v3
+        uses: saucelabs/saucectl-run-action@bc81720eb01738d9c664b07fe42621bd0014283f # pin@v3
         if: github.event_name == 'pull_request' && env.SAUCE_USERNAME != null
         env:
           GITHUB_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index bbaaa88f53a..0549577f629 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -43,7 +43,7 @@ jobs:
         run: make assembleUiTests
 
       - name: Install SauceLabs CLI
-        uses: saucelabs/saucectl-run-action@39e4f0666ca8ecb4b60847213c6e0fbd6a0c2bd8 # pin@v4.3.0
+        uses: saucelabs/saucectl-run-action@bc81720eb01738d9c664b07fe42621bd0014283f # pin@v4.4.0
         env:
           GITHUB_TOKEN: ${{ github.token }}
         with:
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 66776935d9e..8464e8d0399 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@3dc647fee3586e57c7c31eb900fdec7cbb44f23f # v2
+        uses: getsentry/craft@bae212ca7aec50bb716eafd387c80bcfb28da937 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index dfe742087d6..38aaacec27a 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -160,7 +160,7 @@ jobs:
             spring-server.txt
 
       - name: Test Report
-        uses: phoenix-actions/test-reporting@f957cd93fc2d848d556fa0d03c57bc79127b6b5e # pin@v15
+        uses: phoenix-actions/test-reporting@7317eea6e13c47348dd0bb318669485157c518d6 # pin@v16
         if: always()
         with:
           name: JUnit Spring Boot 2.x ${{ matrix.springboot-version }}
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 577f0144179..629535e282d 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -160,7 +160,7 @@ jobs:
             spring-server.txt
 
       - name: Test Report
-        uses: phoenix-actions/test-reporting@f957cd93fc2d848d556fa0d03c57bc79127b6b5e # pin@v15
+        uses: phoenix-actions/test-reporting@7317eea6e13c47348dd0bb318669485157c518d6 # pin@v16
         if: always()
         with:
           name: JUnit Spring Boot 3.x ${{ matrix.springboot-version }}
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 5246cf90cdd..bbd4f986d96 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -160,7 +160,7 @@ jobs:
             spring-server.txt
 
       - name: Test Report
-        uses: phoenix-actions/test-reporting@f957cd93fc2d848d556fa0d03c57bc79127b6b5e # pin@v15
+        uses: phoenix-actions/test-reporting@7317eea6e13c47348dd0bb318669485157c518d6 # pin@v16
         if: always()
         with:
           name: JUnit Spring Boot 4.x ${{ matrix.springboot-version }}
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 321d6ae5652..007fe575d14 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -162,7 +162,7 @@ jobs:
             spring-server.txt
 
       - name: Test Report
-        uses: phoenix-actions/test-reporting@f957cd93fc2d848d556fa0d03c57bc79127b6b5e # pin@v15
+        uses: phoenix-actions/test-reporting@7317eea6e13c47348dd0bb318669485157c518d6 # pin@v16
         if: always()
         with:
           name: JUnit System Tests ${{ matrix.sample }}

From d3b16ee7f4aaffbc53e65ad762c3194e7c6718a3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 11 May 2026 10:43:04 +0200
Subject: [PATCH 144/391] chore(deps): bump
 com.launchdarkly:launchdarkly-java-server-sdk (#5394)

Bumps [com.launchdarkly:launchdarkly-java-server-sdk](https://github.com/launchdarkly/java-core) from 7.10.2 to 7.13.4.
- [Release notes](https://github.com/launchdarkly/java-core/releases)
- [Commits](https://github.com/launchdarkly/java-core/compare/launchdarkly-java-server-sdk-7.10.2...launchdarkly-java-server-sdk-7.13.4)

---
updated-dependencies:
- dependency-name: com.launchdarkly:launchdarkly-java-server-sdk
  dependency-version: 7.13.4
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 gradle/libs.versions.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 8b7cbee3700..ab39c981b44 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -122,7 +122,7 @@ kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutine
 ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktorClient" }
 ktor-client-java = { module = "io.ktor:ktor-client-java", version.ref = "ktorClient" }
 launchdarkly-android = { module = "com.launchdarkly:launchdarkly-android-client-sdk", version = "5.9.2" }
-launchdarkly-server = { module = "com.launchdarkly:launchdarkly-java-server-sdk", version = "7.10.2" }
+launchdarkly-server = { module = "com.launchdarkly:launchdarkly-java-server-sdk", version = "7.13.4" }
 log4j-api = { module = "org.apache.logging.log4j:log4j-api", version.ref = "log4j2" }
 log4j-core = { module = "org.apache.logging.log4j:log4j-core", version.ref = "log4j2" }
 leakcanary = { module = "com.squareup.leakcanary:leakcanary-android", version = "2.14" }

From 48277cdf92e11f1b1956f117735957b4bdf7008b Mon Sep 17 00:00:00 2001
From: Stefan Jandl <reg@bitfox.at>
Date: Mon, 11 May 2026 11:28:44 +0200
Subject: [PATCH 145/391] feat: added `ANR_REPORT_HISTORICAL` to the
 `ManifestMetaDataReader` (#5387)

---
 CHANGELOG.md                                  |  6 +++++
 .../android/core/ManifestMetadataReader.java  |  4 +++
 .../core/ManifestMetadataReaderTest.kt        | 25 +++++++++++++++++++
 3 files changed, 35 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 681753db082..ceda85d8b99 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- Add support to configure reporting historical ANRs via `AndroidManifest.xml` using the  `io.sentry.anr.report-historical` attribute ([#5387](https://github.com/getsentry/sentry-java/pull/5387))
+
 ## 8.41.0
 
 ### Features
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 7dd6f1c1488..b52634774d6 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -33,6 +33,7 @@ final class ManifestMetadataReader {
   static final String ANR_REPORT_DEBUG = "io.sentry.anr.report-debug";
   static final String ANR_TIMEOUT_INTERVAL_MILLIS = "io.sentry.anr.timeout-interval-millis";
   static final String ANR_ATTACH_THREAD_DUMPS = "io.sentry.anr.attach-thread-dumps";
+  static final String ANR_REPORT_HISTORICAL = "io.sentry.anr.report-historical";
 
   static final String TOMBSTONE_ENABLE = "io.sentry.tombstone.enable";
 
@@ -254,6 +255,9 @@ static void applyMetadata(
         options.setAttachAnrThreadDump(
             readBool(metadata, logger, ANR_ATTACH_THREAD_DUMPS, options.isAttachAnrThreadDump()));
 
+        options.setReportHistoricalAnrs(
+            readBool(metadata, logger, ANR_REPORT_HISTORICAL, options.isReportHistoricalAnrs()));
+
         final @Nullable String dsn = readString(metadata, logger, DSN, options.getDsn());
         final boolean enabled = readBool(metadata, logger, ENABLE_SENTRY, options.isEnabled());
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index 52cb085b1ee..cedf5ca18bb 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -288,6 +288,31 @@ class ManifestMetadataReaderTest {
     assertEquals(false, fixture.options.isAttachAnrThreadDump)
   }
 
+  @Test
+  fun `applyMetadata reads anr report historical to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.ANR_REPORT_HISTORICAL to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(true, fixture.options.isReportHistoricalAnrs)
+  }
+
+  @Test
+  fun `applyMetadata reads anr report historical to options and keeps default`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(false, fixture.options.isReportHistoricalAnrs)
+  }
+
   @Test
   fun `applyMetadata reads activity breadcrumbs to options`() {
     // Arrange

From f26c741ed9ebb9d0647921f474fcea33f92d743f Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 12 May 2026 10:04:34 +0200
Subject: [PATCH 146/391] chore: Remove dependabot grouping for gradle deps
 (#5406)

Keep only the github-actions grouping. Individual PRs for gradle
dependencies make it easier to review and merge them independently.

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .github/dependabot.yml | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 10325576354..2824699563c 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -16,21 +16,6 @@ updates:
       - dependency-name: "org.springframework.boot*"
     commit-message:
       prefix: "chore(deps)"
-    groups:
-      compose:
-        patterns:
-          - "androidx.compose*"
-          - "org.jetbrains.compose*"
-      androidx:
-        patterns:
-          - "androidx.*"
-      kotlin:
-        patterns:
-          - "org.jetbrains.kotlin*"
-          - "org.jetbrains.kotlinx*"
-      jackson:
-        patterns:
-          - "com.fasterxml.jackson*"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:

From e0bd00576b1905a3ec3b37b97861eddc35dd4529 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 May 2026 08:34:43 +0000
Subject: [PATCH 147/391] chore(deps): bump urllib3 in the uv group across 1
 directory (#5405)

Bumps the uv group with 1 update in the / directory: [urllib3](https://github.com/urllib3/urllib3).


Updates `urllib3` from 2.6.3 to 2.7.0
- [Release notes](https://github.com/urllib3/urllib3/releases)
- [Changelog](https://github.com/urllib3/urllib3/blob/main/CHANGES.rst)
- [Commits](https://github.com/urllib3/urllib3/compare/2.6.3...2.7.0)

---
updated-dependencies:
- dependency-name: urllib3
  dependency-version: 2.7.0
  dependency-type: direct:production
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index ace4a3e0374..8bdd5f892df 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,4 +2,4 @@ certifi==2025.7.14
 charset-normalizer==3.4.2
 idna==3.10
 requests==2.33.0
-urllib3==2.6.3
+urllib3==2.7.0

From 16da8b8f402c9c3fa5915c9093dbade965ec42c3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 May 2026 08:46:32 +0000
Subject: [PATCH 148/391] chore(deps): bump spotless from 7.0.4 to 8.4.0
 (#5411)

* chore(deps): bump spotless from 7.0.4 to 8.4.0

Bumps `spotless` from 7.0.4 to 8.4.0.

Updates `com.diffplug.spotless:com.diffplug.spotless.gradle.plugin` from 7.0.4 to 8.4.0

Updates `com.diffplug.spotless` from 7.0.4 to 8.4.0

---
updated-dependencies:
- dependency-name: com.diffplug.spotless:com.diffplug.spotless.gradle.plugin
  dependency-version: 8.4.0
  dependency-type: direct:production
  update-type: version-update:semver-major
- dependency-name: com.diffplug.spotless
  dependency-version: 8.4.0
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

* Format code

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 gradle/libs.versions.toml                     |  2 +-
 .../android/core/AnrV2IntegrationTest.kt      | 92 +++++++++----------
 .../sentry/android/core/SentryAndroidTest.kt  | 58 ++++++------
 .../debugmeta/AssetsDebugMetaLoaderTest.kt    | 24 ++---
 .../modules/AssetsModulesLoaderTest.kt        | 16 ++--
 .../distribution/UpdateResponseParserTest.kt  | 30 +++---
 .../uitest/android/critical/MainActivity.kt   |  6 +-
 .../io/sentry/uitest/android/EnvelopeTests.kt |  8 +-
 .../viewhierarchy/ComposeViewHierarchyNode.kt | 22 ++---
 .../replay/AnrWithReplayIntegrationTest.kt    | 58 ++++++------
 .../graphql22/SentryInstrumentationTest.kt    | 14 +--
 .../graphql/SentryInstrumentationTest.kt      | 14 +--
 .../src/main/kotlin/io/sentry/Assertions.kt   |  8 +-
 .../io/sentry/JsonObjectDeserializerTest.kt   | 52 +++++------
 .../debugmeta/ResourcesDebugMetaLoaderTest.kt | 84 ++++++++---------
 .../modules/ResourcesModulesLoaderTest.kt     | 16 ++--
 .../io/sentry/util/CollectionUtilsTest.kt     | 12 +--
 17 files changed, 258 insertions(+), 258 deletions(-)

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index ab39c981b44..4a17b2ac237 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -37,7 +37,7 @@ springboot4 = "4.0.0"
 targetSdk = "36"
 compileSdk = "36"
 minSdk = "21"
-spotless = "7.0.4"
+spotless = "8.4.0"
 gummyBears = "0.12.0"
 camerax = "1.4.0"
 openfeature = "1.18.2"
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2IntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2IntegrationTest.kt
index abd27b51560..d9fd9c1889e 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2IntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AnrV2IntegrationTest.kt
@@ -56,29 +56,29 @@ class AnrV2IntegrationTest : ApplicationExitIntegrationTestBase<AnrV2Hint>() {
               whenever(mock.traceInputStream)
                 .thenReturn(
                   """
-                            Subject: Input dispatching timed out (7985007 com.example.app/com.example.app.ui.MainActivity (server) is not responding. Waited 5000ms for FocusEvent(hasFocus=false))
-                            Here are no Binder-related exception messages available.
-                            Pid(12233) have D state thread(tid:12236 name:Signal Catcher)
+                  Subject: Input dispatching timed out (7985007 com.example.app/com.example.app.ui.MainActivity (server) is not responding. Waited 5000ms for FocusEvent(hasFocus=false))
+                  Here are no Binder-related exception messages available.
+                  Pid(12233) have D state thread(tid:12236 name:Signal Catcher)
 
 
-                            RssHwmKb: 823716
-                            RssKb: 548348
-                            RssAnonKb: 382156
-                            RssShmemKb: 13304
-                            VmSwapKb: 82484
+                  RssHwmKb: 823716
+                  RssKb: 548348
+                  RssAnonKb: 382156
+                  RssShmemKb: 13304
+                  VmSwapKb: 82484
 
 
-                            --- CriticalEventLog ---
-                            capacity: 20
-                            timestamp_ms: 1731507490032
-                            window_ms: 300000
+                  --- CriticalEventLog ---
+                  capacity: 20
+                  timestamp_ms: 1731507490032
+                  window_ms: 300000
 
-                            ----- dumping pid: 12233 at 313446151
-                            libdebuggerd_client: unexpected registration response: 0
+                  ----- dumping pid: 12233 at 313446151
+                  libdebuggerd_client: unexpected registration response: 0
 
-                            ----- Waiting Channels: pid 12233 at 2024-11-13 19:48:09.980104540+0530 -----
-                            Cmd line: com.example.app:mainProcess
-                            """
+                  ----- Waiting Channels: pid 12233 at 2024-11-13 19:48:09.980104540+0530 -----
+                  Cmd line: com.example.app:mainProcess
+                  """
                     .trimIndent()
                     .byteInputStream()
                 )
@@ -86,35 +86,35 @@ class AnrV2IntegrationTest : ApplicationExitIntegrationTestBase<AnrV2Hint>() {
               whenever(mock.traceInputStream)
                 .thenReturn(
                   """
-"main" prio=5 tid=1 Blocked
-  | group="main" sCount=1 ucsCount=0 flags=1 obj=0x72a985e0 self=0xb400007cabc57380
-  | sysTid=28941 nice=-10 cgrp=top-app sched=0/0 handle=0x7deceb74f8
-  | state=S schedstat=( 324804784 183300334 997 ) utm=23 stm=8 core=3 HZ=100
-  | stack=0x7ff93a9000-0x7ff93ab000 stackSize=8188KB
-  | held mutexes=
-  at io.sentry.samples.android.MainActivity${'$'}2.run(MainActivity.java:177)
-  - waiting to lock <0x0d3a2f0a> (a java.lang.Object) held by thread 5
-  at android.os.Handler.handleCallback(Handler.java:942)
-  at android.os.Handler.dispatchMessage(Handler.java:99)
-  at android.os.Looper.loopOnce(Looper.java:201)
-  at android.os.Looper.loop(Looper.java:288)
-  at android.app.ActivityThread.main(ActivityThread.java:7872)
-  at java.lang.reflect.Method.invoke(Native method)
-  at com.android.internal.os.RuntimeInit${'$'}MethodAndArgsCaller.run(RuntimeInit.java:548)
-  at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:936)
-
-"perfetto_hprof_listener" prio=10 tid=7 Native (still starting up)
-  | group="" sCount=1 ucsCount=0 flags=1 obj=0x0 self=0xb400007cabc5ab20
-  | sysTid=28959 nice=-20 cgrp=top-app sched=0/0 handle=0x7b2021bcb0
-  | state=S schedstat=( 72750 1679167 1 ) utm=0 stm=0 core=3 HZ=100
-  | stack=0x7b20124000-0x7b20126000 stackSize=991KB
-  | held mutexes=
-  native: #00 pc 00000000000a20f4  /apex/com.android.runtime/lib64/bionic/libc.so (read+4) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
-  native: #01 pc 000000000001d840  /apex/com.android.art/lib64/libperfetto_hprof.so (void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, ArtPlugin_Initialize::${'$'}_34> >(void*)+260) (BuildId: 525cc92a7dc49130157aeb74f6870364)
-  native: #02 pc 00000000000b63b0  /apex/com.android.runtime/lib64/bionic/libc.so (__pthread_start(void*)+208) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
-  native: #03 pc 00000000000530b8  /apex/com.android.runtime/lib64/bionic/libc.so (__start_thread+64) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
-  (no managed stack frames)
-                            """
+                  "main" prio=5 tid=1 Blocked
+                    | group="main" sCount=1 ucsCount=0 flags=1 obj=0x72a985e0 self=0xb400007cabc57380
+                    | sysTid=28941 nice=-10 cgrp=top-app sched=0/0 handle=0x7deceb74f8
+                    | state=S schedstat=( 324804784 183300334 997 ) utm=23 stm=8 core=3 HZ=100
+                    | stack=0x7ff93a9000-0x7ff93ab000 stackSize=8188KB
+                    | held mutexes=
+                    at io.sentry.samples.android.MainActivity${'$'}2.run(MainActivity.java:177)
+                    - waiting to lock <0x0d3a2f0a> (a java.lang.Object) held by thread 5
+                    at android.os.Handler.handleCallback(Handler.java:942)
+                    at android.os.Handler.dispatchMessage(Handler.java:99)
+                    at android.os.Looper.loopOnce(Looper.java:201)
+                    at android.os.Looper.loop(Looper.java:288)
+                    at android.app.ActivityThread.main(ActivityThread.java:7872)
+                    at java.lang.reflect.Method.invoke(Native method)
+                    at com.android.internal.os.RuntimeInit${'$'}MethodAndArgsCaller.run(RuntimeInit.java:548)
+                    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:936)
+
+                  "perfetto_hprof_listener" prio=10 tid=7 Native (still starting up)
+                    | group="" sCount=1 ucsCount=0 flags=1 obj=0x0 self=0xb400007cabc5ab20
+                    | sysTid=28959 nice=-20 cgrp=top-app sched=0/0 handle=0x7b2021bcb0
+                    | state=S schedstat=( 72750 1679167 1 ) utm=0 stm=0 core=3 HZ=100
+                    | stack=0x7b20124000-0x7b20126000 stackSize=991KB
+                    | held mutexes=
+                    native: #00 pc 00000000000a20f4  /apex/com.android.runtime/lib64/bionic/libc.so (read+4) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
+                    native: #01 pc 000000000001d840  /apex/com.android.art/lib64/libperfetto_hprof.so (void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, ArtPlugin_Initialize::${'$'}_34> >(void*)+260) (BuildId: 525cc92a7dc49130157aeb74f6870364)
+                    native: #02 pc 00000000000b63b0  /apex/com.android.runtime/lib64/bionic/libc.so (__pthread_start(void*)+208) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
+                    native: #03 pc 00000000000530b8  /apex/com.android.runtime/lib64/bionic/libc.so (__start_thread+64) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
+                    (no managed stack frames)
+                  """
                     .trimIndent()
                     .byteInputStream()
                 )
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
index 9c0f68c3f98..8524a1cc807 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
@@ -132,35 +132,35 @@ class SentryAndroidTest {
           whenever(mock.traceInputStream)
             .thenReturn(
               """
-"main" prio=5 tid=1 Blocked
-  | group="main" sCount=1 ucsCount=0 flags=1 obj=0x72a985e0 self=0xb400007cabc57380
-  | sysTid=28941 nice=-10 cgrp=top-app sched=0/0 handle=0x7deceb74f8
-  | state=S schedstat=( 324804784 183300334 997 ) utm=23 stm=8 core=3 HZ=100
-  | stack=0x7ff93a9000-0x7ff93ab000 stackSize=8188KB
-  | held mutexes=
-  at io.sentry.samples.android.MainActivity${'$'}2.run(MainActivity.java:177)
-  - waiting to lock <0x0d3a2f0a> (a java.lang.Object) held by thread 5
-  at android.os.Handler.handleCallback(Handler.java:942)
-  at android.os.Handler.dispatchMessage(Handler.java:99)
-  at android.os.Looper.loopOnce(Looper.java:201)
-  at android.os.Looper.loop(Looper.java:288)
-  at android.app.ActivityThread.main(ActivityThread.java:7872)
-  at java.lang.reflect.Method.invoke(Native method)
-  at com.android.internal.os.RuntimeInit${'$'}MethodAndArgsCaller.run(RuntimeInit.java:548)
-  at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:936)
-
-"perfetto_hprof_listener" prio=10 tid=7 Native (still starting up)
-  | group="" sCount=1 ucsCount=0 flags=1 obj=0x0 self=0xb400007cabc5ab20
-  | sysTid=28959 nice=-20 cgrp=top-app sched=0/0 handle=0x7b2021bcb0
-  | state=S schedstat=( 72750 1679167 1 ) utm=0 stm=0 core=3 HZ=100
-  | stack=0x7b20124000-0x7b20126000 stackSize=991KB
-  | held mutexes=
-  native: #00 pc 00000000000a20f4  /apex/com.android.runtime/lib64/bionic/libc.so (read+4) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
-  native: #01 pc 000000000001d840  /apex/com.android.art/lib64/libperfetto_hprof.so (void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, ArtPlugin_Initialize::${'$'}_34> >(void*)+260) (BuildId: 525cc92a7dc49130157aeb74f6870364)
-  native: #02 pc 00000000000b63b0  /apex/com.android.runtime/lib64/bionic/libc.so (__pthread_start(void*)+208) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
-  native: #03 pc 00000000000530b8  /apex/com.android.runtime/lib64/bionic/libc.so (__start_thread+64) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
-  (no managed stack frames)
-                        """
+              "main" prio=5 tid=1 Blocked
+                | group="main" sCount=1 ucsCount=0 flags=1 obj=0x72a985e0 self=0xb400007cabc57380
+                | sysTid=28941 nice=-10 cgrp=top-app sched=0/0 handle=0x7deceb74f8
+                | state=S schedstat=( 324804784 183300334 997 ) utm=23 stm=8 core=3 HZ=100
+                | stack=0x7ff93a9000-0x7ff93ab000 stackSize=8188KB
+                | held mutexes=
+                at io.sentry.samples.android.MainActivity${'$'}2.run(MainActivity.java:177)
+                - waiting to lock <0x0d3a2f0a> (a java.lang.Object) held by thread 5
+                at android.os.Handler.handleCallback(Handler.java:942)
+                at android.os.Handler.dispatchMessage(Handler.java:99)
+                at android.os.Looper.loopOnce(Looper.java:201)
+                at android.os.Looper.loop(Looper.java:288)
+                at android.app.ActivityThread.main(ActivityThread.java:7872)
+                at java.lang.reflect.Method.invoke(Native method)
+                at com.android.internal.os.RuntimeInit${'$'}MethodAndArgsCaller.run(RuntimeInit.java:548)
+                at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:936)
+
+              "perfetto_hprof_listener" prio=10 tid=7 Native (still starting up)
+                | group="" sCount=1 ucsCount=0 flags=1 obj=0x0 self=0xb400007cabc5ab20
+                | sysTid=28959 nice=-20 cgrp=top-app sched=0/0 handle=0x7b2021bcb0
+                | state=S schedstat=( 72750 1679167 1 ) utm=0 stm=0 core=3 HZ=100
+                | stack=0x7b20124000-0x7b20126000 stackSize=991KB
+                | held mutexes=
+                native: #00 pc 00000000000a20f4  /apex/com.android.runtime/lib64/bionic/libc.so (read+4) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
+                native: #01 pc 000000000001d840  /apex/com.android.art/lib64/libperfetto_hprof.so (void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, ArtPlugin_Initialize::${'$'}_34> >(void*)+260) (BuildId: 525cc92a7dc49130157aeb74f6870364)
+                native: #02 pc 00000000000b63b0  /apex/com.android.runtime/lib64/bionic/libc.so (__pthread_start(void*)+208) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
+                native: #03 pc 00000000000530b8  /apex/com.android.runtime/lib64/bionic/libc.so (__start_thread+64) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
+                (no managed stack frames)
+              """
                 .trimIndent()
                 .byteInputStream()
             )
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/debugmeta/AssetsDebugMetaLoaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/debugmeta/AssetsDebugMetaLoaderTest.kt
index ba11c3c7966..76f13b63822 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/debugmeta/AssetsDebugMetaLoaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/debugmeta/AssetsDebugMetaLoaderTest.kt
@@ -45,12 +45,12 @@ class AssetsDebugMetaLoaderTest {
       fixture.getSut(
         content =
           """
-                    #Generated by sentry-maven-plugin
-                    #Wed May 17 15:33:34 CEST 2023
-                    io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
-                    io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
-                    io.sentry.build-tool=maven
-                    """
+          #Generated by sentry-maven-plugin
+          #Wed May 17 15:33:34 CEST 2023
+          io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
+          io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
+          io.sentry.build-tool=maven
+          """
             .trimIndent()
       )
 
@@ -68,12 +68,12 @@ class AssetsDebugMetaLoaderTest {
       fixture.getSut(
         content =
           """
-                    #Generated by sentry-maven-plugin
-                    #Wed May 17 15:33:34 CEST 2023
-                    io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
-                    io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68,8d11a44a-facd-46c1-a49b-87d256227101
-                    io.sentry.build-tool=maven
-                    """
+          #Generated by sentry-maven-plugin
+          #Wed May 17 15:33:34 CEST 2023
+          io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
+          io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68,8d11a44a-facd-46c1-a49b-87d256227101
+          io.sentry.build-tool=maven
+          """
             .trimIndent()
       )
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/modules/AssetsModulesLoaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/modules/AssetsModulesLoaderTest.kt
index 128087a315d..34d03b175d7 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/modules/AssetsModulesLoaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/modules/AssetsModulesLoaderTest.kt
@@ -44,9 +44,9 @@ class AssetsModulesLoaderTest {
       fixture.getSut(
         content =
           """
-                    com.squareup.okhttp3:okhttp:3.14.9
-                    com.squareup.okio:okio:1.17.2
-                    """
+          com.squareup.okhttp3:okhttp:3.14.9
+          com.squareup.okio:okio:1.17.2
+          """
             .trimIndent()
       )
 
@@ -62,9 +62,9 @@ class AssetsModulesLoaderTest {
       fixture.getSut(
         content =
           """
-                    com.squareup.okhttp3:okhttp:3.14.9
-                    com.squareup.okio:okio:1.17.2
-                    """
+          com.squareup.okhttp3:okhttp:3.14.9
+          com.squareup.okio:okio:1.17.2
+          """
             .trimIndent()
       )
 
@@ -93,8 +93,8 @@ class AssetsModulesLoaderTest {
       fixture.getSut(
         content =
           """
-                    com.squareup.okhttp3;3.14.9
-                    """
+          com.squareup.okhttp3;3.14.9
+          """
             .trimIndent()
       )
 
diff --git a/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt b/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt
index 89013c430dd..3f1d083919c 100644
--- a/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt
+++ b/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt
@@ -37,7 +37,7 @@ class UpdateResponseParserTest {
         },
         "current": null
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -68,7 +68,7 @@ class UpdateResponseParserTest {
           "created_date": "2023-09-01T00:00:00Z"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -90,7 +90,7 @@ class UpdateResponseParserTest {
           "created_date": "2023-09-01T00:00:00Z"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -146,7 +146,7 @@ class UpdateResponseParserTest {
           "build_version": "2.0.0"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -173,7 +173,7 @@ class UpdateResponseParserTest {
           "created_date": ""
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -214,7 +214,7 @@ class UpdateResponseParserTest {
           "created_date": "2023-10-01T00:00:00Z"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -240,7 +240,7 @@ class UpdateResponseParserTest {
           "created_date": "2023-10-01T00:00:00Z"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -266,7 +266,7 @@ class UpdateResponseParserTest {
           "created_date": "2023-10-01T00:00:00Z"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -292,7 +292,7 @@ class UpdateResponseParserTest {
           "created_date": "2023-10-01T00:00:00Z"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -316,7 +316,7 @@ class UpdateResponseParserTest {
           "created_date": "2023-10-01T00:00:00Z"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -345,7 +345,7 @@ class UpdateResponseParserTest {
           "created_date": "2023-10-01T00:00:00Z"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -372,7 +372,7 @@ class UpdateResponseParserTest {
           "created_date": "2023-10-01T00:00:00Z"
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -397,7 +397,7 @@ class UpdateResponseParserTest {
           "install_groups": []
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -422,7 +422,7 @@ class UpdateResponseParserTest {
           "install_groups": null
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
@@ -447,7 +447,7 @@ class UpdateResponseParserTest {
           "install_groups": ["beta-testers"]
         }
       }
-    """
+      """
         .trimIndent()
 
     val result = parser.parseResponse(200, responseBody)
diff --git a/sentry-android-integration-tests/sentry-uitest-android-critical/src/main/java/io/sentry/uitest/android/critical/MainActivity.kt b/sentry-android-integration-tests/sentry-uitest-android-critical/src/main/java/io/sentry/uitest/android/critical/MainActivity.kt
index f6b81c869ef..46bfe7e44b7 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-critical/src/main/java/io/sentry/uitest/android/critical/MainActivity.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android-critical/src/main/java/io/sentry/uitest/android/critical/MainActivity.kt
@@ -69,9 +69,9 @@ class MainActivity : ComponentActivity() {
                 val file = File(outboxPath, "corrupted.envelope")
                 val corruptedEnvelopeContent =
                   """
-                                {"event_id":"1990b5bc31904b7395fd07feb72daf1c","sdk":{"name":"sentry.java.android","version":"7.21.0"}}
-                                {"type":"test","length":50}
-                                """
+                  {"event_id":"1990b5bc31904b7395fd07feb72daf1c","sdk":{"name":"sentry.java.android","version":"7.21.0"}}
+                  {"type":"test","length":50}
+                  """
                     .trimIndent()
                 file.writeText(corruptedEnvelopeContent)
                 println("Wrote corrupted envelope to: ${file.absolutePath}")
diff --git a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/EnvelopeTests.kt b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/EnvelopeTests.kt
index 30cdfefde25..ade47363296 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/EnvelopeTests.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/EnvelopeTests.kt
@@ -267,10 +267,10 @@ class EnvelopeTests : BaseUiTest() {
     File(optionsRef!!.outboxPath, "14779dbf-b2f0-4c00-f4e5-4a287abc4267")
       .writeText(
         """
-                {"dsn":"https://key@sentry.io/proj","event_id":"729ff878-5539-458d-f657-a1acf423a127","sent_at":"2025-04-02T10:02:04.732577Z"}
-                {"type":"transaction","length":1335}
-                {"event_id":"729ff878-5539-458d-f657-a1acf423a127","platform":"native","transaction":"little.teapot","start_timestamp":"2025-04-02T10:02:04.731697Z","spans":[{"op":"littlest.teapot","span_id":"00028ba394454124","status":"ok","trace_id":"7160e289fe4c4496f02c72bbc7edb392","parent_span_id":"b0dc1649a8ec4101","description":null,"start_timestamp":"2025-04-02T10:02:04.732127Z","timestamp":"2025-04-02T10:02:04.732133Z"},{"op":"littler.teapot","span_id":"b0dc1649a8ec4101","status":"ok","trace_id":"7160e289fe4c4496f02c72bbc7edb392","parent_span_id":"7ad2e40529af4650","description":null,"start_timestamp":"2025-04-02T10:02:04.732118Z","data":{"span_data_says":"hi!"},"timestamp":"2025-04-02T10:02:04.732137Z"}],"type":"transaction","timestamp":"2025-04-02T10:02:04.732142Z","level":"info","contexts":{"trace":{"trace_id":"7160e289fe4c4496f02c72bbc7edb392","span_id":"7ad2e40529af4650","op":"Short and stout here is my handle and here is my spout","status":"ok","data":{"url":"https://example.com"}},"os":{"build":"android14-4-00257-g7e35917775b8-ab9964412","name":"Linux","version":"6.1.23"}},"release":"1.0.0","dist":"dist","environment":"production","sdk":{"name":"io.sentry.ndk","version":"0.8.3","packages":[{"name":"github:getsentry/sentry-native","version":"0.8.3"}],"integrations":["inproc"]},"tags":{},"extra":{},"breadcrumbs":[]}
-                """
+        {"dsn":"https://key@sentry.io/proj","event_id":"729ff878-5539-458d-f657-a1acf423a127","sent_at":"2025-04-02T10:02:04.732577Z"}
+        {"type":"transaction","length":1335}
+        {"event_id":"729ff878-5539-458d-f657-a1acf423a127","platform":"native","transaction":"little.teapot","start_timestamp":"2025-04-02T10:02:04.731697Z","spans":[{"op":"littlest.teapot","span_id":"00028ba394454124","status":"ok","trace_id":"7160e289fe4c4496f02c72bbc7edb392","parent_span_id":"b0dc1649a8ec4101","description":null,"start_timestamp":"2025-04-02T10:02:04.732127Z","timestamp":"2025-04-02T10:02:04.732133Z"},{"op":"littler.teapot","span_id":"b0dc1649a8ec4101","status":"ok","trace_id":"7160e289fe4c4496f02c72bbc7edb392","parent_span_id":"7ad2e40529af4650","description":null,"start_timestamp":"2025-04-02T10:02:04.732118Z","data":{"span_data_says":"hi!"},"timestamp":"2025-04-02T10:02:04.732137Z"}],"type":"transaction","timestamp":"2025-04-02T10:02:04.732142Z","level":"info","contexts":{"trace":{"trace_id":"7160e289fe4c4496f02c72bbc7edb392","span_id":"7ad2e40529af4650","op":"Short and stout here is my handle and here is my spout","status":"ok","data":{"url":"https://example.com"}},"os":{"build":"android14-4-00257-g7e35917775b8-ab9964412","name":"Linux","version":"6.1.23"}},"release":"1.0.0","dist":"dist","environment":"production","sdk":{"name":"io.sentry.ndk","version":"0.8.3","packages":[{"name":"github:getsentry/sentry-native","version":"0.8.3"}],"integrations":["inproc"]},"tags":{},"extra":{},"breadcrumbs":[]}
+        """
           .trimIndent()
       )
 
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
index ec01d28d4fb..a0312b69cd0 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
@@ -137,12 +137,12 @@ internal object ComposeViewHierarchyNode {
           SentryLevel.ERROR,
           t,
           """
-                    Error retrieving semantics information from Compose tree. Most likely you're using
-                    an unsupported version of androidx.compose.ui:ui. The supported
-                    version range is 1.5.0 - 1.10.2.
-                    If you're using a newer version, please open a github issue with the version
-                    you're using, so we can add support for it.
-                    """
+          Error retrieving semantics information from Compose tree. Most likely you're using
+          an unsupported version of androidx.compose.ui:ui. The supported
+          version range is 1.5.0 - 1.10.2.
+          If you're using a newer version, please open a github issue with the version
+          you're using, so we can add support for it.
+          """
             .trimIndent(),
         )
       }
@@ -284,11 +284,11 @@ internal object ComposeViewHierarchyNode {
         SentryLevel.ERROR,
         e,
         """
-                Error traversing Compose tree. Most likely you're using an unsupported version of
-                androidx.compose.ui:ui. The minimum supported version is 1.5.0. If it's a newer
-                version, please open a github issue with the version you're using, so we can add
-                support for it.
-                """
+        Error traversing Compose tree. Most likely you're using an unsupported version of
+        androidx.compose.ui:ui. The minimum supported version is 1.5.0. If it's a newer
+        version, please open a github issue with the version you're using, so we can add
+        support for it.
+        """
           .trimIndent(),
       )
       return false
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/AnrWithReplayIntegrationTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/AnrWithReplayIntegrationTest.kt
index f3d03fd5bc5..1214c55c057 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/AnrWithReplayIntegrationTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/AnrWithReplayIntegrationTest.kt
@@ -80,35 +80,35 @@ class AnrWithReplayIntegrationTest {
           whenever(mock.traceInputStream)
             .thenReturn(
               """
-"main" prio=5 tid=1 Blocked
-  | group="main" sCount=1 ucsCount=0 flags=1 obj=0x72a985e0 self=0xb400007cabc57380
-  | sysTid=28941 nice=-10 cgrp=top-app sched=0/0 handle=0x7deceb74f8
-  | state=S schedstat=( 324804784 183300334 997 ) utm=23 stm=8 core=3 HZ=100
-  | stack=0x7ff93a9000-0x7ff93ab000 stackSize=8188KB
-  | held mutexes=
-  at io.sentry.samples.android.MainActivity${'$'}2.run(MainActivity.java:177)
-  - waiting to lock <0x0d3a2f0a> (a java.lang.Object) held by thread 5
-  at android.os.Handler.handleCallback(Handler.java:942)
-  at android.os.Handler.dispatchMessage(Handler.java:99)
-  at android.os.Looper.loopOnce(Looper.java:201)
-  at android.os.Looper.loop(Looper.java:288)
-  at android.app.ActivityThread.main(ActivityThread.java:7872)
-  at java.lang.reflect.Method.invoke(Native method)
-  at com.android.internal.os.RuntimeInit${'$'}MethodAndArgsCaller.run(RuntimeInit.java:548)
-  at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:936)
-
-"perfetto_hprof_listener" prio=10 tid=7 Native (still starting up)
-  | group="" sCount=1 ucsCount=0 flags=1 obj=0x0 self=0xb400007cabc5ab20
-  | sysTid=28959 nice=-20 cgrp=top-app sched=0/0 handle=0x7b2021bcb0
-  | state=S schedstat=( 72750 1679167 1 ) utm=0 stm=0 core=3 HZ=100
-  | stack=0x7b20124000-0x7b20126000 stackSize=991KB
-  | held mutexes=
-  native: #00 pc 00000000000a20f4  /apex/com.android.runtime/lib64/bionic/libc.so (read+4) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
-  native: #01 pc 000000000001d840  /apex/com.android.art/lib64/libperfetto_hprof.so (void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, ArtPlugin_Initialize::${'$'}_34> >(void*)+260) (BuildId: 525cc92a7dc49130157aeb74f6870364)
-  native: #02 pc 00000000000b63b0  /apex/com.android.runtime/lib64/bionic/libc.so (__pthread_start(void*)+208) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
-  native: #03 pc 00000000000530b8  /apex/com.android.runtime/lib64/bionic/libc.so (__start_thread+64) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
-  (no managed stack frames)
-                        """
+              "main" prio=5 tid=1 Blocked
+                | group="main" sCount=1 ucsCount=0 flags=1 obj=0x72a985e0 self=0xb400007cabc57380
+                | sysTid=28941 nice=-10 cgrp=top-app sched=0/0 handle=0x7deceb74f8
+                | state=S schedstat=( 324804784 183300334 997 ) utm=23 stm=8 core=3 HZ=100
+                | stack=0x7ff93a9000-0x7ff93ab000 stackSize=8188KB
+                | held mutexes=
+                at io.sentry.samples.android.MainActivity${'$'}2.run(MainActivity.java:177)
+                - waiting to lock <0x0d3a2f0a> (a java.lang.Object) held by thread 5
+                at android.os.Handler.handleCallback(Handler.java:942)
+                at android.os.Handler.dispatchMessage(Handler.java:99)
+                at android.os.Looper.loopOnce(Looper.java:201)
+                at android.os.Looper.loop(Looper.java:288)
+                at android.app.ActivityThread.main(ActivityThread.java:7872)
+                at java.lang.reflect.Method.invoke(Native method)
+                at com.android.internal.os.RuntimeInit${'$'}MethodAndArgsCaller.run(RuntimeInit.java:548)
+                at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:936)
+
+              "perfetto_hprof_listener" prio=10 tid=7 Native (still starting up)
+                | group="" sCount=1 ucsCount=0 flags=1 obj=0x0 self=0xb400007cabc5ab20
+                | sysTid=28959 nice=-20 cgrp=top-app sched=0/0 handle=0x7b2021bcb0
+                | state=S schedstat=( 72750 1679167 1 ) utm=0 stm=0 core=3 HZ=100
+                | stack=0x7b20124000-0x7b20126000 stackSize=991KB
+                | held mutexes=
+                native: #00 pc 00000000000a20f4  /apex/com.android.runtime/lib64/bionic/libc.so (read+4) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
+                native: #01 pc 000000000001d840  /apex/com.android.art/lib64/libperfetto_hprof.so (void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, ArtPlugin_Initialize::${'$'}_34> >(void*)+260) (BuildId: 525cc92a7dc49130157aeb74f6870364)
+                native: #02 pc 00000000000b63b0  /apex/com.android.runtime/lib64/bionic/libc.so (__pthread_start(void*)+208) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
+                native: #03 pc 00000000000530b8  /apex/com.android.runtime/lib64/bionic/libc.so (__start_thread+64) (BuildId: 01331f74b0bb2cb958bdc15282b8ec7b)
+                (no managed stack frames)
+              """
                 .trimIndent()
                 .byteInputStream()
             )
diff --git a/sentry-graphql-22/src/test/kotlin/io/sentry/graphql22/SentryInstrumentationTest.kt b/sentry-graphql-22/src/test/kotlin/io/sentry/graphql22/SentryInstrumentationTest.kt
index e61fb44a856..c684688299e 100644
--- a/sentry-graphql-22/src/test/kotlin/io/sentry/graphql22/SentryInstrumentationTest.kt
+++ b/sentry-graphql-22/src/test/kotlin/io/sentry/graphql22/SentryInstrumentationTest.kt
@@ -54,14 +54,14 @@ class SentryInstrumentationTest {
       activeSpan = SentryTracer(TransactionContext("name", "op"), scopes)
       val schema =
         """
-                type Query {
-                    shows: [Show]
-                }
+        type Query {
+            shows: [Show]
+        }
 
-                type Show {
-                    id: Int
-                }
-                """
+        type Show {
+            id: Int
+        }
+        """
           .trimIndent()
 
       val graphQLSchema =
diff --git a/sentry-graphql/src/test/kotlin/io/sentry/graphql/SentryInstrumentationTest.kt b/sentry-graphql/src/test/kotlin/io/sentry/graphql/SentryInstrumentationTest.kt
index 1e2e5c8f0f0..972b091a226 100644
--- a/sentry-graphql/src/test/kotlin/io/sentry/graphql/SentryInstrumentationTest.kt
+++ b/sentry-graphql/src/test/kotlin/io/sentry/graphql/SentryInstrumentationTest.kt
@@ -50,14 +50,14 @@ class SentryInstrumentationTest {
       activeSpan = SentryTracer(TransactionContext("name", "op"), scopes)
       val schema =
         """
-                type Query {
-                    shows: [Show]
-                }
+        type Query {
+            shows: [Show]
+        }
 
-                type Show {
-                    id: Int
-                }
-                """
+        type Show {
+            id: Int
+        }
+        """
           .trimIndent()
 
       val graphQLSchema =
diff --git a/sentry-test-support/src/main/kotlin/io/sentry/Assertions.kt b/sentry-test-support/src/main/kotlin/io/sentry/Assertions.kt
index 8d621adb1a2..43b083d50e9 100644
--- a/sentry-test-support/src/main/kotlin/io/sentry/Assertions.kt
+++ b/sentry-test-support/src/main/kotlin/io/sentry/Assertions.kt
@@ -118,11 +118,11 @@ private inline fun <reified T : Any> check(noinline predicate: (T) -> Unit): T =
     if (arg == null) {
       error(
         """
-                The argument passed to the predicate was null.
+                        The argument passed to the predicate was null.
 
-If you are trying to verify an argument to be null, use `isNull()`.
-If you are using `check` as part of a stubbing, use `argThat` or `argForWhich` instead.
-                """
+        If you are trying to verify an argument to be null, use `isNull()`.
+        If you are using `check` as part of a stubbing, use `argThat` or `argForWhich` instead.
+        """
           .trimIndent()
       )
     }
diff --git a/sentry/src/test/java/io/sentry/JsonObjectDeserializerTest.kt b/sentry/src/test/java/io/sentry/JsonObjectDeserializerTest.kt
index 3e60f4ff8a7..04e2aaceba0 100644
--- a/sentry/src/test/java/io/sentry/JsonObjectDeserializerTest.kt
+++ b/sentry/src/test/java/io/sentry/JsonObjectDeserializerTest.kt
@@ -162,12 +162,12 @@ class JsonObjectDeserializerTest {
   fun `deserialize json object object`() {
     val json =
       """
-            {
-                "key": {
-                    "key": "value"
-                }
-            }
-            """
+      {
+          "key": {
+              "key": "value"
+          }
+      }
+      """
         .trimIndent()
     val expected = mapOf<String, Any>("key" to mapOf("key" to "value"))
 
@@ -179,26 +179,26 @@ class JsonObjectDeserializerTest {
   fun `deserialize json object object with nesting`() {
     val json =
       """
-            {
-                "fixture-key":
-                {
-                    "string": "fixture-string",
-                    "int": 123,
-                    "double": 123.321,
-                    "boolean": true,
-                    "array":
-                    [
-                        "a",
-                        "b",
-                        "c"
-                    ],
-                    "object":
-                    {
-                        "key": "value"
-                    }
-                }
-            }
-            """
+      {
+          "fixture-key":
+          {
+              "string": "fixture-string",
+              "int": 123,
+              "double": 123.321,
+              "boolean": true,
+              "array":
+              [
+                  "a",
+                  "b",
+                  "c"
+              ],
+              "object":
+              {
+                  "key": "value"
+              }
+          }
+      }
+      """
         .trimIndent()
 
     val expected =
diff --git a/sentry/src/test/java/io/sentry/internal/debugmeta/ResourcesDebugMetaLoaderTest.kt b/sentry/src/test/java/io/sentry/internal/debugmeta/ResourcesDebugMetaLoaderTest.kt
index 0e776717436..59bc9012348 100644
--- a/sentry/src/test/java/io/sentry/internal/debugmeta/ResourcesDebugMetaLoaderTest.kt
+++ b/sentry/src/test/java/io/sentry/internal/debugmeta/ResourcesDebugMetaLoaderTest.kt
@@ -51,12 +51,12 @@ class ResourcesDebugMetaLoaderTest {
         content =
           listOf(
             """
-                        #Generated by sentry-maven-plugin
-                        #Wed May 17 15:33:34 CEST 2023
-                        io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
-                        io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
-                        io.sentry.build-tool=maven
-                        """
+            #Generated by sentry-maven-plugin
+            #Wed May 17 15:33:34 CEST 2023
+            io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
+            io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
+            io.sentry.build-tool=maven
+            """
               .trimIndent()
           )
       )
@@ -76,12 +76,12 @@ class ResourcesDebugMetaLoaderTest {
         content =
           listOf(
             """
-                        #Generated by sentry-maven-plugin
-                        #Wed May 17 15:33:34 CEST 2023
-                        io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
-                        io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68,8d11a44a-facd-46c1-a49b-87d256227101
-                        io.sentry.build-tool=maven
-                        """
+            #Generated by sentry-maven-plugin
+            #Wed May 17 15:33:34 CEST 2023
+            io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
+            io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68,8d11a44a-facd-46c1-a49b-87d256227101
+            io.sentry.build-tool=maven
+            """
               .trimIndent()
           )
       )
@@ -104,20 +104,20 @@ class ResourcesDebugMetaLoaderTest {
         content =
           listOf(
             """
-                        #Generated by sentry-maven-plugin
-                        #Wed May 17 15:33:34 CEST 2023
-                        io.sentry.ProguardUuids=7b1fae93-63fb-43ff-a70a-608dc5005970
-                        io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68,8d11a44a-facd-46c1-a49b-87d256227101
-                        io.sentry.build-tool=maven
-                        """
+            #Generated by sentry-maven-plugin
+            #Wed May 17 15:33:34 CEST 2023
+            io.sentry.ProguardUuids=7b1fae93-63fb-43ff-a70a-608dc5005970
+            io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68,8d11a44a-facd-46c1-a49b-87d256227101
+            io.sentry.build-tool=maven
+            """
               .trimIndent(),
             """
-                        #Generated by sentry-maven-plugin
-                        #Wed May 17 15:33:34 CEST 2023
-                        io.sentry.ProguardUuids=37c90685-32a1-40db-9019-a2f0b05674cb
-                        io.sentry.bundle-ids=13e16819-accf-48da-a82d-f6ec94af9948
-                        io.sentry.build-tool=maven
-                        """
+            #Generated by sentry-maven-plugin
+            #Wed May 17 15:33:34 CEST 2023
+            io.sentry.ProguardUuids=37c90685-32a1-40db-9019-a2f0b05674cb
+            io.sentry.bundle-ids=13e16819-accf-48da-a82d-f6ec94af9948
+            io.sentry.build-tool=maven
+            """
               .trimIndent(),
           )
       )
@@ -151,13 +151,13 @@ class ResourcesDebugMetaLoaderTest {
         content =
           listOf(
             """
-                #Generated by sentry-maven-plugin
-                #Wed May 17 15:33:34 CEST 2023
-                io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
-                io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
-                io.sentry.build-tool=maven
-                io.sentry.build-tool-version=1.0
-                """
+            #Generated by sentry-maven-plugin
+            #Wed May 17 15:33:34 CEST 2023
+            io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
+            io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
+            io.sentry.build-tool=maven
+            io.sentry.build-tool-version=1.0
+            """
               .trimIndent()
           )
       )
@@ -176,12 +176,12 @@ class ResourcesDebugMetaLoaderTest {
         content =
           listOf(
             """
-                #Generated by sentry-maven-plugin
-                #Wed May 17 15:33:34 CEST 2023
-                io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
-                io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
-                io.sentry.build-tool=maven
-                """
+            #Generated by sentry-maven-plugin
+            #Wed May 17 15:33:34 CEST 2023
+            io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
+            io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
+            io.sentry.build-tool=maven
+            """
               .trimIndent()
           )
       )
@@ -200,11 +200,11 @@ class ResourcesDebugMetaLoaderTest {
         content =
           listOf(
             """
-                #Generated manually
-                #Wed May 17 15:33:34 CEST 2023
-                io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
-                io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
-                """
+            #Generated manually
+            #Wed May 17 15:33:34 CEST 2023
+            io.sentry.ProguardUuids=34077988-a0e5-4839-9618-7400e1616d1b
+            io.sentry.bundle-ids=88ba82db-cd26-4c09-8b31-21461d286b68
+            """
               .trimIndent()
           )
       )
diff --git a/sentry/src/test/java/io/sentry/internal/modules/ResourcesModulesLoaderTest.kt b/sentry/src/test/java/io/sentry/internal/modules/ResourcesModulesLoaderTest.kt
index d9791fd7608..290fc0d0c0b 100644
--- a/sentry/src/test/java/io/sentry/internal/modules/ResourcesModulesLoaderTest.kt
+++ b/sentry/src/test/java/io/sentry/internal/modules/ResourcesModulesLoaderTest.kt
@@ -35,9 +35,9 @@ class ResourcesModulesLoaderTest {
       fixture.getSut(
         content =
           """
-                    com.squareup.okhttp3:okhttp:3.14.9
-                    com.squareup.okio:okio:1.17.2
-                    """
+          com.squareup.okhttp3:okhttp:3.14.9
+          com.squareup.okio:okio:1.17.2
+          """
             .trimIndent()
       )
 
@@ -53,9 +53,9 @@ class ResourcesModulesLoaderTest {
       fixture.getSut(
         content =
           """
-                    com.squareup.okhttp3:okhttp:3.14.9
-                    com.squareup.okio:okio:1.17.2
-                    """
+          com.squareup.okhttp3:okhttp:3.14.9
+          com.squareup.okio:okio:1.17.2
+          """
             .trimIndent()
       )
 
@@ -84,8 +84,8 @@ class ResourcesModulesLoaderTest {
       fixture.getSut(
         content =
           """
-                    com.squareup.okhttp3;3.14.9
-                    """
+          com.squareup.okhttp3;3.14.9
+          """
             .trimIndent()
       )
 
diff --git a/sentry/src/test/java/io/sentry/util/CollectionUtilsTest.kt b/sentry/src/test/java/io/sentry/util/CollectionUtilsTest.kt
index f5b358d9763..1b1ffc02493 100644
--- a/sentry/src/test/java/io/sentry/util/CollectionUtilsTest.kt
+++ b/sentry/src/test/java/io/sentry/util/CollectionUtilsTest.kt
@@ -46,12 +46,12 @@ class CollectionUtilsTest {
   fun `concurrent hashmap creation ignores null values`() {
     val json =
       """
-            {
-                "key1": "value1",
-                "key2": null,
-                "key3": "value3"
-            }
-            """
+      {
+          "key1": "value1",
+          "key2": null,
+          "key3": "value3"
+      }
+      """
         .trimIndent()
     val reader = JsonObjectReader(StringReader(json))
     val deserializedMap = reader.nextObjectOrNull() as Map<String, String>

From 4ffeec8c0020ea4305a5bd1c1ebab575e130b579 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 May 2026 08:47:44 +0000
Subject: [PATCH 149/391] chore(deps): bump
 androidx.constraintlayout:constraintlayout (#5416)

Bumps androidx.constraintlayout:constraintlayout from 2.0.4 to 2.2.1.

---
updated-dependencies:
- dependency-name: androidx.constraintlayout:constraintlayout
  dependency-version: 2.2.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 gradle/libs.versions.toml                                       | 2 +-
 .../test-app-plain/build.gradle.kts                             | 2 +-
 .../test-app-sentry/build.gradle.kts                            | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 4a17b2ac237..ae13fb664bd 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -86,7 +86,7 @@ androidx-compose-material-icons-extended = { module = "androidx.compose.material
 androidx-compose-ui = { module = "androidx.compose.ui:ui", version.ref = "androidxCompose" }
 # Note: don't change without testing forwards compatibility
 androidx-compose-ui-replay = { module = "androidx.compose.ui:ui", version = "1.10.2" }
-androidx-constraintlayout = { module = "androidx.constraintlayout:constraintlayout", version = "2.1.3" }
+androidx-constraintlayout = { module = "androidx.constraintlayout:constraintlayout", version = "2.2.1" }
 androidx-core = { module = "androidx.core:core", version = "1.3.2" }
 androidx-core-ktx = { module = "androidx.core:core-ktx", version = "1.7.0" }
 androidx-fragment-ktx = { module = "androidx.fragment:fragment-ktx", version = "1.3.5" }
diff --git a/sentry-android-integration-tests/test-app-plain/build.gradle.kts b/sentry-android-integration-tests/test-app-plain/build.gradle.kts
index 4d6655132c3..9778363ede8 100644
--- a/sentry-android-integration-tests/test-app-plain/build.gradle.kts
+++ b/sentry-android-integration-tests/test-app-plain/build.gradle.kts
@@ -45,7 +45,7 @@ android {
 dependencies {
   implementation("androidx.appcompat:appcompat:1.3.0")
   implementation("com.google.android.material:material:1.4.0")
-  implementation("androidx.constraintlayout:constraintlayout:2.0.4")
+  implementation("androidx.constraintlayout:constraintlayout:2.2.1")
   implementation("androidx.navigation:navigation-fragment:2.3.5")
   implementation("androidx.navigation:navigation-ui:2.3.5")
 }
diff --git a/sentry-android-integration-tests/test-app-sentry/build.gradle.kts b/sentry-android-integration-tests/test-app-sentry/build.gradle.kts
index cd340b9a4a6..db0cb4a46ab 100644
--- a/sentry-android-integration-tests/test-app-sentry/build.gradle.kts
+++ b/sentry-android-integration-tests/test-app-sentry/build.gradle.kts
@@ -45,7 +45,7 @@ android {
 dependencies {
   implementation("androidx.appcompat:appcompat:1.3.0")
   implementation("com.google.android.material:material:1.4.0")
-  implementation("androidx.constraintlayout:constraintlayout:2.0.4")
+  implementation("androidx.constraintlayout:constraintlayout:2.2.1")
   implementation("androidx.navigation:navigation-fragment:2.3.5")
   implementation("androidx.navigation:navigation-ui:2.3.5")
   implementation(projects.sentryAndroid)

From 1f987ea15b2878502b59e75518b08577211f2cc7 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 12 May 2026 16:28:32 +0200
Subject: [PATCH 150/391] Remove testBuildType mechanism from UI test modules
 (#5388)

* fix(build): Remove testBuildType mechanism from UI test modules

The debug and release build types were configured identically in
both uitest modules (same minification, proguard rules, signing).
Disable the debug variant unconditionally, hardcode testBuildType
to release, and combine the now-simplified Gradle invocations.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(build): Combine Gradle invocations in AGENTS.md

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/workflows/agp-matrix.yml               |  2 +-
 AGENTS.md                                      |  3 +--
 Makefile                                       |  6 ++----
 .../build.gradle.kts                           | 18 ++++--------------
 .../sentry-uitest-android/README.md            |  6 ++----
 .../sentry-uitest-android/build.gradle.kts     | 13 ++++---------
 6 files changed, 14 insertions(+), 34 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index df0b0ebca3c..7ef34ea563e 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -90,7 +90,7 @@ jobs:
           disable-spellchecker: true
           emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none
           disk-size: 4096M
-          script: ./gradlew sentry-android-integration-tests:sentry-uitest-android:connectedReleaseAndroidTest -DtestBuildType=release -Denvironment=github --daemon
+          script: ./gradlew sentry-android-integration-tests:sentry-uitest-android:connectedReleaseAndroidTest -Denvironment=github --daemon
 
       - name: Upload test results
         if: always()
diff --git a/AGENTS.md b/AGENTS.md
index 42a8e651004..1784e4f950e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -75,8 +75,7 @@ make systemTest
 ### Android-Specific Commands
 ```bash
 # Assemble Android test APKs
-./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleRelease
-./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleAndroidTest -DtestBuildType=release
+./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleRelease :sentry-android-integration-tests:sentry-uitest-android:assembleAndroidTest
 
 # Run critical UI tests
 ./scripts/test-ui-critical.sh
diff --git a/Makefile b/Makefile
index 55f465a9663..c9eca8b8b7e 100644
--- a/Makefile
+++ b/Makefile
@@ -37,13 +37,11 @@ api:
 
 # Assemble release and Android test apk of the uitest-android-benchmark module
 assembleBenchmarkTestRelease:
-	./gradlew :sentry-android-integration-tests:sentry-uitest-android-benchmark:assembleRelease
-	./gradlew :sentry-android-integration-tests:sentry-uitest-android-benchmark:assembleAndroidTest -DtestBuildType=release
+	./gradlew :sentry-android-integration-tests:sentry-uitest-android-benchmark:assembleRelease :sentry-android-integration-tests:sentry-uitest-android-benchmark:assembleAndroidTest
 
 # Assemble release and Android test apk of the uitest-android module
 assembleUiTestRelease:
-	./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleRelease
-	./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleAndroidTest -DtestBuildType=release
+	./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleRelease :sentry-android-integration-tests:sentry-uitest-android:assembleAndroidTest
 
 # Assemble release of the uitest-android-critical module
 assembleUiTestCriticalRelease:
diff --git a/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
index 4b5993644ee..459c1653fa9 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
@@ -46,21 +46,9 @@ android {
     }
   }
 
-  testBuildType = System.getProperty("testBuildType", "debug")
+  testBuildType = "release"
 
   buildTypes {
-    getByName("debug") {
-      isMinifyEnabled = true
-      signingConfig = signingConfigs.getByName("debug")
-      proguardFiles(
-        getDefaultProguardFile("proguard-android-optimize.txt"),
-        "benchmark-proguard-rules.pro",
-      )
-      testProguardFiles(
-        getDefaultProguardFile("proguard-android-optimize.txt"),
-        "benchmark-proguard-rules.pro",
-      )
-    }
     getByName("release") {
       isMinifyEnabled = true
       isShrinkResources = true
@@ -89,7 +77,9 @@ android {
   }
 
   androidComponents.beforeVariants {
-    it.enable = !Config.Android.shouldSkipDebugVariant(it.buildType)
+    if (it.buildType == "debug") {
+      it.enable = false
+    }
   }
 }
 
diff --git a/sentry-android-integration-tests/sentry-uitest-android/README.md b/sentry-android-integration-tests/sentry-uitest-android/README.md
index c11397383d0..08389e0c16c 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/README.md
+++ b/sentry-android-integration-tests/sentry-uitest-android/README.md
@@ -14,14 +14,12 @@ You can run benchmark tests only with `./gradlew :sentry-android-integration-tes
 To run on saucelabs execute following commands (need also `SAUCE_USERNAME` and `SAUCE_ACCESS_KEY` environment variables):
 For Benchmarks:
 ```
-./gradlew :sentry-android-integration-tests:sentry-uitest-android-benchmark:assembleRelease
-./gradlew :sentry-android-integration-tests:sentry-uitest-android-benchmark:assembleAndroidTest -DtestBuildType=release
+./gradlew :sentry-android-integration-tests:sentry-uitest-android-benchmark:assembleRelease :sentry-android-integration-tests:sentry-uitest-android-benchmark:assembleAndroidTest
 saucectl run -c .sauce/sentry-uitest-android-benchmark.yml
 ```
 For End 2 End:
 ```
-./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleRelease
-./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleAndroidTest -DtestBuildType=release
+./gradlew :sentry-android-integration-tests:sentry-uitest-android:assembleRelease :sentry-android-integration-tests:sentry-uitest-android:assembleAndroidTest
 saucectl run -c .sauce/sentry-uitest-android-end2end.yml
 ```
 
diff --git a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
index a4d46405fb8..5258a33f92a 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
@@ -51,18 +51,11 @@ android {
     }
   }
 
-  testBuildType = System.getProperty("testBuildType", "debug")
+  testBuildType = "release"
 
   buildTypes {
-    getByName("debug") {
-      isMinifyEnabled = true
-      signingConfig = signingConfigs.getByName("debug")
-      proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
-      testProguardFiles("proguard-rules.pro")
-    }
     getByName("release") {
       isMinifyEnabled = true
-      isShrinkResources = false
       proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
       signingConfig = signingConfigs.getByName("debug") // to be able to run release mode
       testProguardFiles("proguard-rules.pro")
@@ -82,7 +75,9 @@ android {
   }
 
   androidComponents.beforeVariants {
-    it.enable = !Config.Android.shouldSkipDebugVariant(it.buildType)
+    if (it.buildType == "debug") {
+      it.enable = false
+    }
   }
 }
 

From d8912da3e338a789eb940dc4e5ba54b97d7b6fde Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 12 May 2026 17:55:17 +0200
Subject: [PATCH 151/391] chore: Add missing binary types to .gitattributes
 (#5420)

Mark *.bin, *.zip, *.jar, and *.gpg as binary to prevent
line-ending conversions and diff noise.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .gitattributes | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.gitattributes b/.gitattributes
index 92fa746b911..f444fd5957d 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -3,6 +3,10 @@
 *.jpg binary
 *.pb binary
 *.gz binary
+*.bin binary
+*.zip binary
+*.jar binary
+*.gpg binary
 
 # These are explicitly windows files and should use crlf
 *.bat           text eol=crlf

From 271ed531ac58a295cca62ff1206e10cf015b58aa Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 13 May 2026 09:33:10 +0200
Subject: [PATCH 152/391] chore: update scripts/update-gradle.sh to v9.5.1
 (#5419)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md                             |   6 +++++
 gradle/wrapper/gradle-wrapper.jar        | Bin 48966 -> 48462 bytes
 gradle/wrapper/gradle-wrapper.properties |   4 ++-
 gradlew                                  |   2 +-
 gradlew.bat                              |  31 ++++++++---------------
 5 files changed, 20 insertions(+), 23 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ceda85d8b99..bfb51947698 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,12 @@
 
 - Add support to configure reporting historical ANRs via `AndroidManifest.xml` using the  `io.sentry.anr.report-historical` attribute ([#5387](https://github.com/getsentry/sentry-java/pull/5387))
 
+### Dependencies
+
+- Bump Gradle from v9.5.0 to v9.5.1 ([#5419](https://github.com/getsentry/sentry-java/pull/5419))
+  - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v951)
+  - [diff](https://github.com/gradle/gradle/compare/v9.5.0...v9.5.1)
+
 ## 8.41.0
 
 ### Features
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index d997cfc60f4cff0e7451d19d49a82fa986695d07..b1b8ef56b44f16b14dc800fa8103a6d89abb526f 100644
GIT binary patch
delta 39760
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

delta 40115
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

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 1a704683a00..df6a6ad763d 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,7 +1,9 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip
 networkTimeout=10000
+retries=0
+retryBackOffMs=500
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index 739907dfd15..b9bb139f790 100755
--- a/gradlew
+++ b/gradlew
@@ -57,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/2d6327017519d23b96af35865dc997fcb544fb40/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
diff --git a/gradlew.bat b/gradlew.bat
index c4bdd3ab8e3..24c62d56f2d 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -23,8 +23,8 @@
 @rem
 @rem ##########################################################################
 
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
+@rem Set local scope for the variables, and ensure extensions are enabled
+setlocal EnableExtensions
 
 set DIRNAME=%~dp0
 if "%DIRNAME%"=="" set DIRNAME=.
@@ -51,7 +51,7 @@ echo. 1>&2
 echo Please set the JAVA_HOME variable in your environment to match the 1>&2
 echo location of your Java installation. 1>&2
 
-goto fail
+"%COMSPEC%" /c exit 1
 
 :findJavaFromJavaHome
 set JAVA_HOME=%JAVA_HOME:"=%
@@ -65,7 +65,7 @@ echo. 1>&2
 echo Please set the JAVA_HOME variable in your environment to match the 1>&2
 echo location of your Java installation. 1>&2
 
-goto fail
+"%COMSPEC%" /c exit 1
 
 :execute
 @rem Setup the command line
@@ -73,21 +73,10 @@ goto fail
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
+@rem which allows us to clear the local environment before executing the java command
+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
 
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+:exitWithErrorLevel
+@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
+"%COMSPEC%" /c exit %ERRORLEVEL%

From 5dee26ba7ca9931bca62b730b210e01063e1c2d1 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 13 May 2026 13:54:17 +0200
Subject: [PATCH 153/391] chore(deps): Bump Robolectric from 4.14 to 4.15
 (#5425)

Co-authored-by: Claude <noreply@anthropic.com>
---
 gradle/libs.versions.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index ae13fb664bd..bf16f9b0edd 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -246,5 +246,5 @@ mockito-inline = { module = "org.mockito:mockito-inline", version = "4.8.0" }
 msgpack = { module = "org.msgpack:msgpack-core", version = "0.9.8" }
 okhttp-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version.ref = "okhttp" }
 okio = { module = "com.squareup.okio:okio", version = "1.13.0" }
-roboelectric = { module = "org.robolectric:robolectric", version = "4.14" }
+roboelectric = { module = "org.robolectric:robolectric", version = "4.15" }
 

From 9745881ec5ee89409a8a274966f7348403bcb501 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 15 May 2026 09:09:58 +0200
Subject: [PATCH 154/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.14.1 (#5433)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 3 +++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bfb51947698..edf15cf84e8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,9 @@
 - Bump Gradle from v9.5.0 to v9.5.1 ([#5419](https://github.com/getsentry/sentry-java/pull/5419))
   - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v951)
   - [diff](https://github.com/gradle/gradle/compare/v9.5.0...v9.5.1)
+- Bump Native SDK from v0.14.0 to v0.14.1 ([#5433](https://github.com/getsentry/sentry-java/pull/5433))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0141)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.14.0...0.14.1)
 
 ## 8.41.0
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index bf16f9b0edd..0d4850d288a 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -151,7 +151,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.14.0" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.14.1" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From d65ecce0b77cf13f8d12dcf36d099420c327b33f Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 15 May 2026 09:41:55 +0200
Subject: [PATCH 155/391] chore: Replace custom Gradle wrapper updater with
 Dependabot (#5421)

Remove the custom `scripts/update-gradle.sh` script and its
corresponding `gradle-wrapper` job in the `update-deps.yml` workflow.
The existing Dependabot `gradle` package ecosystem already handles
Gradle wrapper updates, making this custom machinery redundant.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/workflows/update-deps.yml | 10 -------
 scripts/update-gradle.sh          | 47 -------------------------------
 2 files changed, 57 deletions(-)
 delete mode 100755 scripts/update-gradle.sh

diff --git a/.github/workflows/update-deps.yml b/.github/workflows/update-deps.yml
index a8bb5f655a1..bfcf9ccfa85 100644
--- a/.github/workflows/update-deps.yml
+++ b/.github/workflows/update-deps.yml
@@ -23,13 +23,3 @@ jobs:
           path: scripts/update-sentry-native-ndk.sh
           name: Native SDK
           ssh-key: ${{ secrets.CI_DEPLOY_KEY }}
-
-  gradle-wrapper:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: getsentry/github-workflows/updater@26f565c05d0dd49f703d238706b775883037d76b # v3
-        with:
-          path: scripts/update-gradle.sh
-          name: Gradle
-          pattern: '^v[0-9.]+$' # only match non-preview versions
-          ssh-key: ${{ secrets.CI_DEPLOY_KEY }}
diff --git a/scripts/update-gradle.sh b/scripts/update-gradle.sh
deleted file mode 100755
index c2bfe979224..00000000000
--- a/scripts/update-gradle.sh
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-cd $(dirname "$0")/../
-
-if [[ -n ${CI+x} ]]; then
-    export JAVA_HOME=$JAVA_HOME_17_X64
-fi
-
-case $1 in
-get-version)
-    # `./gradlew` shows some info on the first run, breaking the parsing in the next step.
-    # Therefore, we run it once without checking any output.
-    ./gradlew --version >/dev/null
-    version="$(./gradlew --version | sed -E -n 's/.*Gradle +([0-9.]+).*/\1/p')"
-
-    # Add trailing ".0" - gradlew outputs '7.1' instead of '7.1.0'
-    if [[ "$version" =~ ^[0-9]\.[0-9]$ ]]; then
-        version="$version.0"
-    fi
-
-    echo "v$version"
-    ;;
-get-repo)
-    echo "https://github.com/gradle/gradle.git"
-    ;;
-set-version)
-    version=$2
-
-    # Remove leading "v"
-    if [[ "$version" == v* ]]; then
-        version="${version:1}"
-    fi
-
-    echo "Setting gradle version to '$version'"
-
-    # This sets version to gradle-wrapper.properties.
-    ./gradlew wrapper --gradle-version "$version"
-
-    # Verify it works.
-    ./gradlew --version
-    ;;
-*)
-    echo "Unknown argument $1"
-    exit 1
-    ;;
-esac

From 8e739fbff43f310efdeb5bd5a66c98a4ccb308a3 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 15 May 2026 14:17:18 +0200
Subject: [PATCH 156/391] chore(deps): Bump Tomcat from 11.0.10 to 11.0.22
 (#5440)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 gradle/libs.versions.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 0d4850d288a..47c74dde9c5 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -213,8 +213,8 @@ gummy-bears-api21 = { module = "com.toasttab.android:gummy-bears-api-21", versio
 # tomcat libraries
 tomcat-catalina = { module = "org.apache.tomcat:tomcat-catalina", version = "9.0.108" }
 tomcat-embed-jasper = { module = "org.apache.tomcat.embed:tomcat-embed-jasper", version = "9.0.108" }
-tomcat-catalina-jakarta = { module = "org.apache.tomcat:tomcat-catalina", version = "11.0.10" }
-tomcat-embed-jasper-jakarta = { module = "org.apache.tomcat.embed:tomcat-embed-jasper", version = "11.0.10" }
+tomcat-catalina-jakarta = { module = "org.apache.tomcat:tomcat-catalina", version = "11.0.22" }
+tomcat-embed-jasper-jakarta = { module = "org.apache.tomcat.embed:tomcat-embed-jasper", version = "11.0.22" }
 
 # test libraries
 androidx-compose-ui-test-junit4 = { module = "androidx.compose.ui:ui-test-junit4", version = "1.9.5" }

From 4c04bb8999d177ffba8c5d68476e2664a043c789 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 15 May 2026 15:55:12 +0200
Subject: [PATCH 157/391] chore(deps): Bump SAGP from 6.0.0-alpha.6 to 6.6.0
 (#5427)

* chore(deps): Bump SAGP from 6.0.0-alpha.6 to 6.6.0

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md              | 3 +++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index edf15cf84e8..93d3888bd36 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,9 @@
 - Bump Native SDK from v0.14.0 to v0.14.1 ([#5433](https://github.com/getsentry/sentry-java/pull/5433))
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0141)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.14.0...0.14.1)
+- Bump SAGP (Sentry Android Gradle Plugin) from v6.0.0-alpha.6 to v6.6.0 ([#5427](https://github.com/getsentry/sentry-java/pull/5427))
+  - [changelog](https://github.com/getsentry/sentry-android-gradle-plugin/blob/main/CHANGELOG.md)
+  - [diff](https://github.com/getsentry/sentry-android-gradle-plugin/compare/6.0.0-alpha.6...6.6.0)
 
 ## 8.41.0
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 47c74dde9c5..7f37847604f 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -66,7 +66,7 @@ springboot4 = { id = "org.springframework.boot", version.ref = "springboot4" }
 spring-dependency-management = { id = "io.spring.dependency-management", version = "1.1.7" }
 gretty = { id = "org.gretty", version = "4.0.0" }
 animalsniffer = { id = "ru.vyarus.animalsniffer", version = "2.0.1" }
-sentry = { id = "io.sentry.android.gradle", version = "6.0.0-alpha.6"}
+sentry = { id = "io.sentry.android.gradle", version = "6.6.0"}
 shadow = { id = "com.gradleup.shadow", version = "9.4.1" }
 
 [libraries]

From f6cdbf09de34beb48f0daec2694ec8913751d89a Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Mon, 18 May 2026 09:52:35 +0200
Subject: [PATCH 158/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.14.2 (#5441)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 +++---
 gradle/libs.versions.toml | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 93d3888bd36..5632b6926b9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,9 +11,9 @@
 - Bump Gradle from v9.5.0 to v9.5.1 ([#5419](https://github.com/getsentry/sentry-java/pull/5419))
   - [changelog](https://github.com/gradle/gradle/blob/master/CHANGELOG.md#v951)
   - [diff](https://github.com/gradle/gradle/compare/v9.5.0...v9.5.1)
-- Bump Native SDK from v0.14.0 to v0.14.1 ([#5433](https://github.com/getsentry/sentry-java/pull/5433))
-  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0141)
-  - [diff](https://github.com/getsentry/sentry-native/compare/0.14.0...0.14.1)
+- Bump Native SDK from v0.14.0 to v0.14.2 ([#5433](https://github.com/getsentry/sentry-java/pull/5433), [#5441](https://github.com/getsentry/sentry-java/pull/5441))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0142)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.14.0...0.14.2)
 - Bump SAGP (Sentry Android Gradle Plugin) from v6.0.0-alpha.6 to v6.6.0 ([#5427](https://github.com/getsentry/sentry-java/pull/5427))
   - [changelog](https://github.com/getsentry/sentry-android-gradle-plugin/blob/main/CHANGELOG.md)
   - [diff](https://github.com/getsentry/sentry-android-gradle-plugin/compare/6.0.0-alpha.6...6.6.0)
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 7f37847604f..4e580db7498 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -151,7 +151,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.14.1" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.14.2" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 48cc9d8840f7adada488dfffc280a9d4e75ef68d Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 19 May 2026 14:00:26 +0200
Subject: [PATCH 159/391] meta(craft): Register missing SDK modules (#5399)

---
 .craft.yml | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/.craft.yml b/.craft.yml
index cb52926ad56..cc4636cd32d 100644
--- a/.craft.yml
+++ b/.craft.yml
@@ -42,16 +42,20 @@ targets:
       maven:io.sentry:sentry-bom:
       maven:io.sentry:sentry-openfeign:
       maven:io.sentry:sentry-openfeature:
+      maven:io.sentry:sentry-launchdarkly-android:
+      maven:io.sentry:sentry-launchdarkly-server:
       maven:io.sentry:sentry-opentelemetry-agent:
       maven:io.sentry:sentry-opentelemetry-agentcustomization:
       maven:io.sentry:sentry-opentelemetry-agentless:
       maven:io.sentry:sentry-opentelemetry-agentless-spring:
       maven:io.sentry:sentry-opentelemetry-bootstrap:
       maven:io.sentry:sentry-opentelemetry-core:
-#      maven:io.sentry:sentry-opentelemetry-otlp:
-#      maven:io.sentry:sentry-opentelemetry-otlp-spring:
+      maven:io.sentry:sentry-opentelemetry-otlp:
+      maven:io.sentry:sentry-opentelemetry-otlp-spring:
+      maven:io.sentry:sentry-kafka:
       maven:io.sentry:sentry-apollo:
       maven:io.sentry:sentry-jdbc:
+      maven:io.sentry:sentry-jcache:
       maven:io.sentry:sentry-graphql:
       maven:io.sentry:sentry-graphql-22:
       maven:io.sentry:sentry-graphql-core:

From 11f90db91673ad57a61458c7b8ce0b3d52646295 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 19 May 2026 14:23:13 +0200
Subject: [PATCH 160/391] feat(core): Add API to clear scope feature flags
 (#5426)

* feat(core): Add API to clear scope feature flags

Allow feature flags stored on a scope to be cleared without resetting other scope data. Scope.clear now also resets the feature flag buffer so stale flag evaluations do not carry over after clearing a scope.

Fixes #5422

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                       |  1 +
 sentry/api/sentry.api                              |  8 ++++++++
 .../src/main/java/io/sentry/CombinedScopeView.java |  5 +++++
 sentry/src/main/java/io/sentry/IScope.java         |  2 ++
 sentry/src/main/java/io/sentry/NoOpScope.java      |  3 +++
 sentry/src/main/java/io/sentry/Scope.java          |  6 ++++++
 .../io/sentry/featureflags/FeatureFlagBuffer.java  |  7 +++++++
 .../io/sentry/featureflags/IFeatureFlagBuffer.java |  2 ++
 .../sentry/featureflags/NoOpFeatureFlagBuffer.java |  3 +++
 .../sentry/featureflags/SpanFeatureFlagBuffer.java |  7 +++++++
 sentry/src/test/java/io/sentry/ScopeTest.kt        | 14 ++++++++++++++
 .../sentry/featureflags/FeatureFlagBufferTest.kt   | 13 +++++++++++++
 .../featureflags/SpanFeatureFlagBufferTest.kt      | 12 ++++++++++++
 13 files changed, 83 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5632b6926b9..4241d6e4f82 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Features
 
+- Add API to clear feature flags from scopes ([#5426](https://github.com/getsentry/sentry-java/pull/5426))
 - Add support to configure reporting historical ANRs via `AndroidManifest.xml` using the  `io.sentry.anr.report-historical` attribute ([#5387](https://github.com/getsentry/sentry-java/pull/5387))
 
 ### Dependencies
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index a433abbb37c..e48c03ffb15 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -273,6 +273,7 @@ public final class io/sentry/CombinedScopeView : io/sentry/IScope {
 	public fun clear ()V
 	public fun clearAttachments ()V
 	public fun clearBreadcrumbs ()V
+	public fun clearFeatureFlags ()V
 	public fun clearSession ()V
 	public fun clearTransaction ()V
 	public fun clone ()Lio/sentry/IScope;
@@ -901,6 +902,7 @@ public abstract interface class io/sentry/IScope {
 	public abstract fun clear ()V
 	public abstract fun clearAttachments ()V
 	public abstract fun clearBreadcrumbs ()V
+	public abstract fun clearFeatureFlags ()V
 	public abstract fun clearSession ()V
 	public abstract fun clearTransaction ()V
 	public abstract fun clone ()Lio/sentry/IScope;
@@ -1715,6 +1717,7 @@ public final class io/sentry/NoOpScope : io/sentry/IScope {
 	public fun clear ()V
 	public fun clearAttachments ()V
 	public fun clearBreadcrumbs ()V
+	public fun clearFeatureFlags ()V
 	public fun clearSession ()V
 	public fun clearTransaction ()V
 	public fun clone ()Lio/sentry/IScope;
@@ -2401,6 +2404,7 @@ public final class io/sentry/Scope : io/sentry/IScope {
 	public fun clear ()V
 	public fun clearAttachments ()V
 	public fun clearBreadcrumbs ()V
+	public fun clearFeatureFlags ()V
 	public fun clearSession ()V
 	public fun clearTransaction ()V
 	public fun clone ()Lio/sentry/IScope;
@@ -5039,6 +5043,7 @@ public final class io/sentry/exception/SentryHttpClientException : java/lang/Exc
 
 public final class io/sentry/featureflags/FeatureFlagBuffer : io/sentry/featureflags/IFeatureFlagBuffer {
 	public fun add (Ljava/lang/String;Ljava/lang/Boolean;)V
+	public fun clear ()V
 	public fun clone ()Lio/sentry/featureflags/IFeatureFlagBuffer;
 	public synthetic fun clone ()Ljava/lang/Object;
 	public static fun create (Lio/sentry/SentryOptions;)Lio/sentry/featureflags/IFeatureFlagBuffer;
@@ -5048,6 +5053,7 @@ public final class io/sentry/featureflags/FeatureFlagBuffer : io/sentry/featuref
 
 public abstract interface class io/sentry/featureflags/IFeatureFlagBuffer {
 	public abstract fun add (Ljava/lang/String;Ljava/lang/Boolean;)V
+	public abstract fun clear ()V
 	public abstract fun clone ()Lio/sentry/featureflags/IFeatureFlagBuffer;
 	public abstract fun getFeatureFlags ()Lio/sentry/protocol/FeatureFlags;
 }
@@ -5055,6 +5061,7 @@ public abstract interface class io/sentry/featureflags/IFeatureFlagBuffer {
 public final class io/sentry/featureflags/NoOpFeatureFlagBuffer : io/sentry/featureflags/IFeatureFlagBuffer {
 	public fun <init> ()V
 	public fun add (Ljava/lang/String;Ljava/lang/Boolean;)V
+	public fun clear ()V
 	public fun clone ()Lio/sentry/featureflags/IFeatureFlagBuffer;
 	public synthetic fun clone ()Ljava/lang/Object;
 	public fun getFeatureFlags ()Lio/sentry/protocol/FeatureFlags;
@@ -5063,6 +5070,7 @@ public final class io/sentry/featureflags/NoOpFeatureFlagBuffer : io/sentry/feat
 
 public final class io/sentry/featureflags/SpanFeatureFlagBuffer : io/sentry/featureflags/IFeatureFlagBuffer {
 	public fun add (Ljava/lang/String;Ljava/lang/Boolean;)V
+	public fun clear ()V
 	public fun clone ()Lio/sentry/featureflags/IFeatureFlagBuffer;
 	public synthetic fun clone ()Ljava/lang/Object;
 	public static fun create ()Lio/sentry/featureflags/IFeatureFlagBuffer;
diff --git a/sentry/src/main/java/io/sentry/CombinedScopeView.java b/sentry/src/main/java/io/sentry/CombinedScopeView.java
index 0c61bdf9126..f21f8697fa4 100644
--- a/sentry/src/main/java/io/sentry/CombinedScopeView.java
+++ b/sentry/src/main/java/io/sentry/CombinedScopeView.java
@@ -549,6 +549,11 @@ public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean
     }
   }
 
+  @Override
+  public void clearFeatureFlags() {
+    getDefaultWriteScope().clearFeatureFlags();
+  }
+
   @Override
   public @Nullable FeatureFlags getFeatureFlags() {
     return getFeatureFlagBuffer().getFeatureFlags();
diff --git a/sentry/src/main/java/io/sentry/IScope.java b/sentry/src/main/java/io/sentry/IScope.java
index ccab8dbdeb3..5b6c38bbcfb 100644
--- a/sentry/src/main/java/io/sentry/IScope.java
+++ b/sentry/src/main/java/io/sentry/IScope.java
@@ -465,6 +465,8 @@ void setSpanContext(
 
   void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result);
 
+  void clearFeatureFlags();
+
   @ApiStatus.Internal
   @Nullable
   FeatureFlags getFeatureFlags();
diff --git a/sentry/src/main/java/io/sentry/NoOpScope.java b/sentry/src/main/java/io/sentry/NoOpScope.java
index 7693ab81deb..9d2f603c673 100644
--- a/sentry/src/main/java/io/sentry/NoOpScope.java
+++ b/sentry/src/main/java/io/sentry/NoOpScope.java
@@ -321,6 +321,9 @@ public void removeAttribute(@Nullable String key) {}
   @Override
   public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean result) {}
 
+  @Override
+  public void clearFeatureFlags() {}
+
   @Override
   public @Nullable FeatureFlags getFeatureFlags() {
     return null;
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index fa44e90a194..9e8d3ee554e 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -574,6 +574,7 @@ public void clear() {
     eventProcessors.clear();
     clearTransaction();
     clearAttachments();
+    clearFeatureFlags();
   }
 
   /**
@@ -1211,6 +1212,11 @@ public void addFeatureFlag(final @Nullable String flag, final @Nullable Boolean
     featureFlags.add(flag, result);
   }
 
+  @Override
+  public void clearFeatureFlags() {
+    featureFlags.clear();
+  }
+
   @Override
   public @Nullable FeatureFlags getFeatureFlags() {
     return featureFlags.getFeatureFlags();
diff --git a/sentry/src/main/java/io/sentry/featureflags/FeatureFlagBuffer.java b/sentry/src/main/java/io/sentry/featureflags/FeatureFlagBuffer.java
index f38d0b6db52..fc696b5948f 100644
--- a/sentry/src/main/java/io/sentry/featureflags/FeatureFlagBuffer.java
+++ b/sentry/src/main/java/io/sentry/featureflags/FeatureFlagBuffer.java
@@ -69,6 +69,13 @@ public void add(final @Nullable String flag, final @Nullable Boolean result) {
     }
   }
 
+  @Override
+  public void clear() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      flags.clear();
+    }
+  }
+
   @Override
   public @Nullable FeatureFlags getFeatureFlags() {
     List<FeatureFlag> featureFlags = new ArrayList<>();
diff --git a/sentry/src/main/java/io/sentry/featureflags/IFeatureFlagBuffer.java b/sentry/src/main/java/io/sentry/featureflags/IFeatureFlagBuffer.java
index 7f12026a590..90a503cce49 100644
--- a/sentry/src/main/java/io/sentry/featureflags/IFeatureFlagBuffer.java
+++ b/sentry/src/main/java/io/sentry/featureflags/IFeatureFlagBuffer.java
@@ -9,6 +9,8 @@
 public interface IFeatureFlagBuffer {
   void add(final @Nullable String flag, final @Nullable Boolean result);
 
+  void clear();
+
   @Nullable
   FeatureFlags getFeatureFlags();
 
diff --git a/sentry/src/main/java/io/sentry/featureflags/NoOpFeatureFlagBuffer.java b/sentry/src/main/java/io/sentry/featureflags/NoOpFeatureFlagBuffer.java
index 3bfc8f8fd2a..e093531149a 100644
--- a/sentry/src/main/java/io/sentry/featureflags/NoOpFeatureFlagBuffer.java
+++ b/sentry/src/main/java/io/sentry/featureflags/NoOpFeatureFlagBuffer.java
@@ -16,6 +16,9 @@ public static NoOpFeatureFlagBuffer getInstance() {
   @Override
   public void add(final @Nullable String flag, final @Nullable Boolean result) {}
 
+  @Override
+  public void clear() {}
+
   @Override
   public @Nullable FeatureFlags getFeatureFlags() {
     return null;
diff --git a/sentry/src/main/java/io/sentry/featureflags/SpanFeatureFlagBuffer.java b/sentry/src/main/java/io/sentry/featureflags/SpanFeatureFlagBuffer.java
index 2afa45d38d1..d31bc231d44 100644
--- a/sentry/src/main/java/io/sentry/featureflags/SpanFeatureFlagBuffer.java
+++ b/sentry/src/main/java/io/sentry/featureflags/SpanFeatureFlagBuffer.java
@@ -48,6 +48,13 @@ public void add(final @Nullable String flag, final @Nullable Boolean result) {
     }
   }
 
+  @Override
+  public void clear() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      flags = null;
+    }
+  }
+
   @Override
   public @Nullable FeatureFlags getFeatureFlags() {
     try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
diff --git a/sentry/src/test/java/io/sentry/ScopeTest.kt b/sentry/src/test/java/io/sentry/ScopeTest.kt
index 7093473a60b..4b0047fdc18 100644
--- a/sentry/src/test/java/io/sentry/ScopeTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopeTest.kt
@@ -294,6 +294,7 @@ class ScopeTest {
     scope.setAttribute("some", "attribute")
     scope.addEventProcessor(eventProcessor())
     scope.addAttachment(Attachment("path"))
+    scope.addFeatureFlag("flag", true)
 
     scope.clear()
 
@@ -309,6 +310,7 @@ class ScopeTest {
     assertEquals(0, scope.extras.size)
     assertEquals(0, scope.eventProcessors.size)
     assertEquals(0, scope.attachments.size)
+    assertEquals(0, scope.featureFlags!!.values.size)
   }
 
   @Test
@@ -1155,6 +1157,18 @@ class ScopeTest {
     assertEquals(0, flags.values.size)
   }
 
+  @Test
+  fun `feature flags can be cleared`() {
+    val scope = Scope(SentryOptions.empty())
+
+    scope.addFeatureFlag("flag1", true)
+    scope.clearFeatureFlags()
+
+    val flags = scope.featureFlags
+    assertNotNull(flags)
+    assertEquals(0, flags.values.size)
+  }
+
   @Test
   fun `setAttribute stores attribute on scope`() {
     val scope = Scope(SentryOptions())
diff --git a/sentry/src/test/java/io/sentry/featureflags/FeatureFlagBufferTest.kt b/sentry/src/test/java/io/sentry/featureflags/FeatureFlagBufferTest.kt
index 471ba880eb4..8ec18ce02b8 100644
--- a/sentry/src/test/java/io/sentry/featureflags/FeatureFlagBufferTest.kt
+++ b/sentry/src/test/java/io/sentry/featureflags/FeatureFlagBufferTest.kt
@@ -33,6 +33,19 @@ class FeatureFlagBufferTest {
     assertFalse(featureFlagValues[1]!!.result)
   }
 
+  @Test
+  fun `clears values`() {
+    val buffer = FeatureFlagBuffer.create(SentryOptions().also { it.maxFeatureFlags = 2 })
+    buffer.add("a", true)
+    buffer.add("b", false)
+
+    buffer.clear()
+
+    val featureFlags = buffer.featureFlags
+    assertNotNull(featureFlags)
+    assertEquals(0, featureFlags.values.size)
+  }
+
   @Test
   fun `drops oldest entry when limit is reached`() {
     val buffer = FeatureFlagBuffer.create(SentryOptions().also { it.maxFeatureFlags = 2 })
diff --git a/sentry/src/test/java/io/sentry/featureflags/SpanFeatureFlagBufferTest.kt b/sentry/src/test/java/io/sentry/featureflags/SpanFeatureFlagBufferTest.kt
index 07c3feaf5c9..c6c89d9f3ab 100644
--- a/sentry/src/test/java/io/sentry/featureflags/SpanFeatureFlagBufferTest.kt
+++ b/sentry/src/test/java/io/sentry/featureflags/SpanFeatureFlagBufferTest.kt
@@ -4,6 +4,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
+import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
 class SpanFeatureFlagBufferTest {
@@ -26,6 +27,17 @@ class SpanFeatureFlagBufferTest {
     assertFalse(featureFlagValues[1]!!.result)
   }
 
+  @Test
+  fun `clears values`() {
+    val buffer = SpanFeatureFlagBuffer.create()
+    buffer.add("a", true)
+    buffer.add("b", false)
+
+    buffer.clear()
+
+    assertNull(buffer.featureFlags)
+  }
+
   @Test
   fun `rejects new entries when limit is reached`() {
     val buffer = SpanFeatureFlagBuffer.create()

From 69508a17fe4442278632fb13fd7f658a94e6f008 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 20 May 2026 12:17:27 +0200
Subject: [PATCH 161/391] feat(tombstones): Add option to attach raw tombstone
 as protobuf (#5446)

* feat(android): Add option to attach raw tombstone as protobuf

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* changelog

* changelog

* ref(android): Rename attachTombstone to attachRawTombstone

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* test(android): Add tests for raw tombstone attachment

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Format code

* fix(android): Close tombstone InputStream after reading bytes

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* ref(android): Extract shared readBytes into NativeEventUtils

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(android): Fix JavaDoc and address review feedback

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* ref(android): Only pre-buffer tombstone bytes when attach option is on

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |  2 +
 .../api/sentry-android-core.api               |  2 +
 .../sentry/android/core/AnrV2Integration.java | 18 +------
 .../android/core/ManifestMetadataReader.java  |  3 ++
 .../android/core/SentryAndroidOptions.java    | 14 +++++
 .../android/core/TombstoneIntegration.java    | 51 ++++++++++++-------
 .../core/internal/util/NativeEventUtils.java  | 15 ++++++
 .../core/ManifestMetadataReaderTest.kt        | 25 +++++++++
 .../android/core/TombstoneIntegrationTest.kt  | 39 ++++++++++++++
 sentry/api/sentry.api                         |  3 ++
 .../src/main/java/io/sentry/Attachment.java   | 10 ++++
 sentry/src/main/java/io/sentry/Hint.java      |  9 ++++
 .../src/main/java/io/sentry/SentryClient.java |  5 ++
 .../test/java/io/sentry/SentryClientTest.kt   | 32 ++++++++++++
 .../src/test/java/io/sentry/hints/HintTest.kt | 11 ++++
 15 files changed, 205 insertions(+), 34 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4241d6e4f82..fca85f96435 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@
 
 ### Features
 
+- Add option to attach raw tombstone protobuf on native crash events ([#5446](https://github.com/getsentry/sentry-java/pull/5446))
+  - Enable via `options.isAttachRawTombstone = true` or manifest: `<meta-data android:name="io.sentry.tombstone.attach-raw" android:value="true" />`
 - Add API to clear feature flags from scopes ([#5426](https://github.com/getsentry/sentry-java/pull/5426))
 - Add support to configure reporting historical ANRs via `AndroidManifest.xml` using the  `io.sentry.anr.report-historical` attribute ([#5387](https://github.com/getsentry/sentry-java/pull/5387))
 
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 3d4512fc2b4..249549f8366 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -374,6 +374,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun isAnrProfilingEnabled ()Z
 	public fun isAnrReportInDebug ()Z
 	public fun isAttachAnrThreadDump ()Z
+	public fun isAttachRawTombstone ()Z
 	public fun isAttachScreenshot ()Z
 	public fun isAttachViewHierarchy ()Z
 	public fun isCollectAdditionalContext ()Z
@@ -401,6 +402,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun setAnrReportInDebug (Z)V
 	public fun setAnrTimeoutIntervalMillis (J)V
 	public fun setAttachAnrThreadDump (Z)V
+	public fun setAttachRawTombstone (Z)V
 	public fun setAttachScreenshot (Z)V
 	public fun setAttachViewHierarchy (Z)V
 	public fun setBeforeScreenshotCaptureCallback (Lio/sentry/android/core/SentryAndroidOptions$BeforeCaptureCallback;)V
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2Integration.java b/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2Integration.java
index af3a942c8cc..8d88285a356 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2Integration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2Integration.java
@@ -18,6 +18,7 @@
 import io.sentry.android.core.cache.AndroidEnvelopeCache;
 import io.sentry.android.core.internal.threaddump.Lines;
 import io.sentry.android.core.internal.threaddump.ThreadDumpParser;
+import io.sentry.android.core.internal.util.NativeEventUtils;
 import io.sentry.hints.AbnormalExit;
 import io.sentry.hints.Backfillable;
 import io.sentry.hints.BlockingFlushHint;
@@ -32,7 +33,6 @@
 import io.sentry.util.Objects;
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
 import java.io.Closeable;
 import java.io.IOException;
 import java.io.InputStream;
@@ -194,7 +194,7 @@ public boolean shouldReportHistorical() {
         if (trace == null) {
           return new ParseResult(ParseResult.Type.NO_DUMP);
         }
-        dump = getDumpBytes(trace);
+        dump = NativeEventUtils.readBytes(trace);
       } catch (Throwable e) {
         options.getLogger().log(SentryLevel.WARNING, "Failed to read ANR thread dump", e);
         return new ParseResult(ParseResult.Type.NO_DUMP);
@@ -223,20 +223,6 @@ public boolean shouldReportHistorical() {
         return new ParseResult(ParseResult.Type.ERROR, dump);
       }
     }
-
-    private byte[] getDumpBytes(final @NotNull InputStream trace) throws IOException {
-      try (final ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
-
-        int nRead;
-        final byte[] data = new byte[1024];
-
-        while ((nRead = trace.read(data, 0, data.length)) != -1) {
-          buffer.write(data, 0, nRead);
-        }
-
-        return buffer.toByteArray();
-      }
-    }
   }
 
   @ApiStatus.Internal
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index b52634774d6..e16d4b312fc 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -36,6 +36,7 @@ final class ManifestMetadataReader {
   static final String ANR_REPORT_HISTORICAL = "io.sentry.anr.report-historical";
 
   static final String TOMBSTONE_ENABLE = "io.sentry.tombstone.enable";
+  static final String TOMBSTONE_ATTACH_RAW = "io.sentry.tombstone.attach-raw";
 
   static final String AUTO_INIT = "io.sentry.auto-init";
   static final String NDK_ENABLE = "io.sentry.ndk.enable";
@@ -226,6 +227,8 @@ static void applyMetadata(
         options.setAnrEnabled(readBool(metadata, logger, ANR_ENABLE, options.isAnrEnabled()));
         options.setTombstoneEnabled(
             readBool(metadata, logger, TOMBSTONE_ENABLE, options.isTombstoneEnabled()));
+        options.setAttachRawTombstone(
+            readBool(metadata, logger, TOMBSTONE_ATTACH_RAW, options.isAttachRawTombstone()));
 
         // use enableAutoSessionTracking as fallback
         options.setEnableAutoSessionTracking(
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
index 8fe702aad50..bb9ec17aabd 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
@@ -238,6 +238,12 @@ public interface BeforeCaptureCallback {
    */
   private boolean attachAnrThreadDump = false;
 
+  /**
+   * Controls whether to attach the raw tombstone protobuf as an attachment. The tombstone is being
+   * attached from {@link ApplicationExitInfo#getTraceInputStream()}, if available.
+   */
+  private boolean attachRawTombstone = false;
+
   private boolean enablePerformanceV2 = true;
 
   private @Nullable SentryFrameMetricsCollector frameMetricsCollector;
@@ -643,6 +649,14 @@ public void setAttachAnrThreadDump(final boolean attachAnrThreadDump) {
     this.attachAnrThreadDump = attachAnrThreadDump;
   }
 
+  public boolean isAttachRawTombstone() {
+    return attachRawTombstone;
+  }
+
+  public void setAttachRawTombstone(final boolean attachRawTombstone) {
+    this.attachRawTombstone = attachRawTombstone;
+  }
+
   /**
    * @return true if performance-v2 is enabled. See {@link #setEnablePerformanceV2(boolean)} for
    *     more details.
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/TombstoneIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/TombstoneIntegration.java
index f2b87742544..2663051f7e4 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/TombstoneIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/TombstoneIntegration.java
@@ -24,6 +24,7 @@
 import io.sentry.android.core.cache.AndroidEnvelopeCache;
 import io.sentry.android.core.internal.tombstone.NativeExceptionMechanism;
 import io.sentry.android.core.internal.tombstone.TombstoneParser;
+import io.sentry.android.core.internal.util.NativeEventUtils;
 import io.sentry.hints.Backfillable;
 import io.sentry.hints.BlockingFlushHint;
 import io.sentry.hints.NativeCrashExit;
@@ -36,6 +37,7 @@
 import io.sentry.transport.ICurrentDateProvider;
 import io.sentry.util.HintUtils;
 import io.sentry.util.Objects;
+import java.io.ByteArrayInputStream;
 import java.io.Closeable;
 import java.io.IOException;
 import java.io.InputStream;
@@ -150,26 +152,35 @@ public boolean shouldReportHistorical() {
     public @Nullable ApplicationExitInfoHistoryDispatcher.Report buildReport(
         final @NotNull ApplicationExitInfo exitInfo, final boolean enrich) {
       SentryEvent event;
+      @Nullable byte[] rawTombstone = null;
       try {
-        final InputStream tombstoneInputStream = exitInfo.getTraceInputStream();
-        if (tombstoneInputStream == null) {
-          options
-              .getLogger()
-              .log(
-                  SentryLevel.WARNING,
-                  "No tombstone InputStream available for ApplicationExitInfo from %s",
-                  DateTimeFormatter.ISO_INSTANT.format(
-                      Instant.ofEpochMilli(exitInfo.getTimestamp())));
-          return null;
-        }
+        final boolean attachRaw = options.isAttachRawTombstone();
+        try (final InputStream tombstoneInputStream = exitInfo.getTraceInputStream()) {
+          if (tombstoneInputStream == null) {
+            options
+                .getLogger()
+                .log(
+                    SentryLevel.WARNING,
+                    "No tombstone InputStream available for ApplicationExitInfo from %s",
+                    DateTimeFormatter.ISO_INSTANT.format(
+                        Instant.ofEpochMilli(exitInfo.getTimestamp())));
+            return null;
+          }
 
-        try (final TombstoneParser parser =
-            new TombstoneParser(
-                tombstoneInputStream,
-                this.options.getInAppIncludes(),
-                this.options.getInAppExcludes(),
-                this.context.getApplicationInfo().nativeLibraryDir)) {
-          event = parser.parse();
+          if (attachRaw) {
+            rawTombstone = NativeEventUtils.readBytes(tombstoneInputStream);
+          }
+
+          final InputStream parserInput =
+              attachRaw ? new ByteArrayInputStream(rawTombstone) : tombstoneInputStream;
+          try (final TombstoneParser parser =
+              new TombstoneParser(
+                  parserInput,
+                  this.options.getInAppIncludes(),
+                  this.options.getInAppExcludes(),
+                  this.context.getApplicationInfo().nativeLibraryDir)) {
+            event = parser.parse();
+          }
         }
       } catch (Throwable e) {
         options
@@ -190,6 +201,10 @@ public boolean shouldReportHistorical() {
               options.getFlushTimeoutMillis(), options.getLogger(), tombstoneTimestamp, enrich);
       final Hint hint = HintUtils.createWithTypeCheckHint(tombstoneHint);
 
+      if (rawTombstone != null) {
+        hint.setTombstone(Attachment.fromTombstone(rawTombstone));
+      }
+
       try {
         final @Nullable SentryEvent mergedEvent =
             mergeWithMatchingNativeEvents(tombstoneTimestamp, event, hint);
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/NativeEventUtils.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/NativeEventUtils.java
index f8bd70cb6c3..c5e766b3c44 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/NativeEventUtils.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/NativeEventUtils.java
@@ -1,5 +1,8 @@
 package io.sentry.android.core.internal.util;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
 import java.math.BigInteger;
 import java.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
@@ -8,6 +11,18 @@
 import org.jetbrains.annotations.Nullable;
 
 public class NativeEventUtils {
+
+  public static byte[] readBytes(final @NotNull InputStream stream) throws IOException {
+    try (final ByteArrayOutputStream buffer = new ByteArrayOutputStream()) {
+      int nRead;
+      final byte[] data = new byte[1024];
+      while ((nRead = stream.read(data, 0, data.length)) != -1) {
+        buffer.write(data, 0, nRead);
+      }
+      return buffer.toByteArray();
+    }
+  }
+
   @Nullable
   public static String buildIdToDebugId(final @NotNull String buildId) {
     try {
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index cedf5ca18bb..d8ac959601a 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -288,6 +288,31 @@ class ManifestMetadataReaderTest {
     assertEquals(false, fixture.options.isAttachAnrThreadDump)
   }
 
+  @Test
+  fun `applyMetadata reads tombstone attach raw to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.TOMBSTONE_ATTACH_RAW to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(true, fixture.options.isAttachRawTombstone)
+  }
+
+  @Test
+  fun `applyMetadata reads tombstone attach raw to options and keeps default`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(false, fixture.options.isAttachRawTombstone)
+  }
+
   @Test
   fun `applyMetadata reads anr report historical to options`() {
     // Arrange
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/TombstoneIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/TombstoneIntegrationTest.kt
index 3b27d69d087..9890d553dbc 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/TombstoneIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/TombstoneIntegrationTest.kt
@@ -96,6 +96,45 @@ class TombstoneIntegrationTest : ApplicationExitIntegrationTestBase<TombstoneHin
     assertEquals(57344, image.imageSize)
   }
 
+  @Test
+  fun `when attachRawTombstone is enabled, raw tombstone is attached to hint`() {
+    val integration =
+      fixture.getSut(tmpDir, lastReportedTimestamp = oldTimestamp) { options ->
+        options.isAttachRawTombstone = true
+      }
+
+    fixture.addAppExitInfo(timestamp = newTimestamp)
+
+    integration.register(fixture.scopes, fixture.options)
+
+    verify(fixture.scopes)
+      .captureEvent(
+        any(),
+        argThat<Hint> {
+          val tombstone = this.tombstone
+          tombstone != null &&
+            tombstone.filename == "tombstone.pb" &&
+            tombstone.contentType == "application/x-protobuf" &&
+            tombstone.bytes != null &&
+            tombstone.bytes!!.isNotEmpty()
+        },
+      )
+  }
+
+  @Test
+  fun `when attachRawTombstone is disabled, no tombstone is attached to hint`() {
+    val integration =
+      fixture.getSut(tmpDir, lastReportedTimestamp = oldTimestamp) { options ->
+        options.isAttachRawTombstone = false
+      }
+
+    fixture.addAppExitInfo(timestamp = newTimestamp)
+
+    integration.register(fixture.scopes, fixture.options)
+
+    verify(fixture.scopes).captureEvent(any(), argThat<Hint> { this.tombstone == null })
+  }
+
   @Test
   fun `when matching native event has attachments, they are added to the hint`() {
     val integration =
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index e48c03ffb15..6b8377de3a3 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -19,6 +19,7 @@ public final class io/sentry/Attachment {
 	public static fun fromByteProvider (Ljava/util/concurrent/Callable;Ljava/lang/String;Ljava/lang/String;Z)Lio/sentry/Attachment;
 	public static fun fromScreenshot ([B)Lio/sentry/Attachment;
 	public static fun fromThreadDump ([B)Lio/sentry/Attachment;
+	public static fun fromTombstone ([B)Lio/sentry/Attachment;
 	public static fun fromViewHierarchy (Lio/sentry/protocol/ViewHierarchy;)Lio/sentry/Attachment;
 	public fun getAttachmentType ()Ljava/lang/String;
 	public fun getByteProvider ()Ljava/util/concurrent/Callable;
@@ -614,6 +615,7 @@ public final class io/sentry/Hint {
 	public fun getReplayRecording ()Lio/sentry/ReplayRecording;
 	public fun getScreenshot ()Lio/sentry/Attachment;
 	public fun getThreadDump ()Lio/sentry/Attachment;
+	public fun getTombstone ()Lio/sentry/Attachment;
 	public fun getViewHierarchy ()Lio/sentry/Attachment;
 	public fun remove (Ljava/lang/String;)V
 	public fun replaceAttachments (Ljava/util/List;)V
@@ -621,6 +623,7 @@ public final class io/sentry/Hint {
 	public fun setReplayRecording (Lio/sentry/ReplayRecording;)V
 	public fun setScreenshot (Lio/sentry/Attachment;)V
 	public fun setThreadDump (Lio/sentry/Attachment;)V
+	public fun setTombstone (Lio/sentry/Attachment;)V
 	public fun setViewHierarchy (Lio/sentry/Attachment;)V
 	public static fun withAttachment (Lio/sentry/Attachment;)Lio/sentry/Hint;
 	public static fun withAttachments (Ljava/util/List;)Lio/sentry/Hint;
diff --git a/sentry/src/main/java/io/sentry/Attachment.java b/sentry/src/main/java/io/sentry/Attachment.java
index 439ad812b0c..3e4cb859e5e 100644
--- a/sentry/src/main/java/io/sentry/Attachment.java
+++ b/sentry/src/main/java/io/sentry/Attachment.java
@@ -396,4 +396,14 @@ boolean isAddToTransactions() {
   public static @NotNull Attachment fromThreadDump(final byte[] bytes) {
     return new Attachment(bytes, "thread-dump.txt", "text/plain", false);
   }
+
+  /**
+   * Creates a new Tombstone Attachment
+   *
+   * @param bytes the array bytes
+   * @return the Attachment
+   */
+  public static @NotNull Attachment fromTombstone(final byte[] bytes) {
+    return new Attachment(bytes, "tombstone.pb", "application/x-protobuf", false);
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/Hint.java b/sentry/src/main/java/io/sentry/Hint.java
index d7949b3133b..1e09dca5541 100644
--- a/sentry/src/main/java/io/sentry/Hint.java
+++ b/sentry/src/main/java/io/sentry/Hint.java
@@ -32,6 +32,7 @@ public final class Hint {
   private @Nullable Attachment screenshot = null;
   private @Nullable Attachment viewHierarchy = null;
   private @Nullable Attachment threadDump = null;
+  private @Nullable Attachment tombstone = null;
   private @Nullable ReplayRecording replayRecording = null;
 
   public static @NotNull Hint withAttachment(@Nullable Attachment attachment) {
@@ -147,6 +148,14 @@ public void setThreadDump(final @Nullable Attachment threadDump) {
     return threadDump;
   }
 
+  public void setTombstone(final @Nullable Attachment tombstone) {
+    this.tombstone = tombstone;
+  }
+
+  public @Nullable Attachment getTombstone() {
+    return tombstone;
+  }
+
   @Nullable
   public ReplayRecording getReplayRecording() {
     return replayRecording;
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index c99fcaeaa2f..6f328d0fd58 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -399,6 +399,11 @@ private boolean shouldSendSessionUpdateForDroppedEvent(
       attachments.add(threadDump);
     }
 
+    @Nullable final Attachment tombstone = hint.getTombstone();
+    if (tombstone != null) {
+      attachments.add(tombstone);
+    }
+
     return attachments;
   }
 
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index 11ff80fd573..663b1f9bdee 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -2124,6 +2124,37 @@ class SentryClientTest {
       .send(check { envelope -> assertEquals(1, envelope.items.count()) }, anyOrNull())
   }
 
+  @Test
+  fun `tombstone is added to the envelope from the hint`() {
+    val sut = fixture.getSut()
+    val attachment = Attachment.fromTombstone(byteArrayOf())
+    val hint = Hint().also { it.tombstone = attachment }
+
+    sut.captureEvent(SentryEvent(), hint)
+
+    verify(fixture.transport)
+      .send(
+        check { envelope ->
+          val tombstone = envelope.items.last()
+          assertNotNull(tombstone) { assertEquals(attachment.filename, tombstone.header.fileName) }
+        },
+        anyOrNull(),
+      )
+  }
+
+  @Test
+  fun `tombstone is dropped from hint via before send`() {
+    fixture.sentryOptions.beforeSend = CustomBeforeSendCallback()
+    val sut = fixture.getSut()
+    val attachment = Attachment.fromTombstone(byteArrayOf())
+    val hint = Hint().also { it.tombstone = attachment }
+
+    sut.captureEvent(SentryEvent(), hint)
+
+    verify(fixture.transport)
+      .send(check { envelope -> assertEquals(1, envelope.items.count()) }, anyOrNull())
+  }
+
   @Test
   fun `capturing an error updates session and sends event + session`() {
     val sut = fixture.getSut()
@@ -3647,6 +3678,7 @@ class SentryClientTest {
       hint.screenshot = null
       hint.viewHierarchy = null
       hint.threadDump = null
+      hint.tombstone = null
       return event
     }
   }
diff --git a/sentry/src/test/java/io/sentry/hints/HintTest.kt b/sentry/src/test/java/io/sentry/hints/HintTest.kt
index 7be03e7dd67..7b0c695bfd4 100644
--- a/sentry/src/test/java/io/sentry/hints/HintTest.kt
+++ b/sentry/src/test/java/io/sentry/hints/HintTest.kt
@@ -210,6 +210,7 @@ class HintTest {
     hint.screenshot = newAttachment("2")
     hint.viewHierarchy = newAttachment("3")
     hint.threadDump = newAttachment("4")
+    hint.tombstone = newAttachment("5")
 
     hint.clear()
 
@@ -219,6 +220,7 @@ class HintTest {
     assertNotNull(hint.screenshot)
     assertNotNull(hint.viewHierarchy)
     assertNotNull(hint.threadDump)
+    assertNotNull(hint.tombstone)
   }
 
   @Test
@@ -248,6 +250,15 @@ class HintTest {
     assertNotNull(hint.threadDump)
   }
 
+  @Test
+  fun `can create hint with a tombstone`() {
+    val hint = Hint()
+    val attachment = newAttachment("tombstone")
+    hint.tombstone = attachment
+
+    assertNotNull(hint.tombstone)
+  }
+
   companion object {
     fun newAttachment(content: String) = Attachment(content.toByteArray(), "$content.txt")
   }

From 01a40a9d2a67409223317b9e93d94d3fa8e3f6dd Mon Sep 17 00:00:00 2001
From: 0xadam-brown <281682121+0xadam-brown@users.noreply.github.com>
Date: Wed, 20 May 2026 12:16:13 +0000
Subject: [PATCH 162/391] release: 8.42.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fca85f96435..3e869e9aac8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.42.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 81fdf72ff04..a8f42329732 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -12,7 +12,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.41.0
+versionName=8.42.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 184b99116b540d45687084b79e0d8d1d9b0483f7 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 20 May 2026 15:35:33 +0200
Subject: [PATCH 163/391] chore(deps): bump idna in the uv group across 1
 directory (#5451)

Bumps the uv group with 1 update in the / directory: [idna](https://github.com/kjd/idna).


Updates `idna` from 3.10 to 3.15
- [Release notes](https://github.com/kjd/idna/releases)
- [Changelog](https://github.com/kjd/idna/blob/master/HISTORY.md)
- [Commits](https://github.com/kjd/idna/compare/v3.10...v3.15)

---
updated-dependencies:
- dependency-name: idna
  dependency-version: '3.15'
  dependency-type: direct:production
  dependency-group: uv
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/requirements.txt b/requirements.txt
index 8bdd5f892df..c573fa72259 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,5 @@
 certifi==2025.7.14
 charset-normalizer==3.4.2
-idna==3.10
+idna==3.15
 requests==2.33.0
 urllib3==2.7.0

From 9392427e0ff0657e38f47ec82342ef2e0fdc2d5a Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Thu, 21 May 2026 12:03:44 +0200
Subject: [PATCH 164/391] chore(ci): Skip Spring Boot tests when updating
 Android modules (#5453)

* chore(ci): Skip Spring Boot matrix jobs on Android-only pull requests (JAVA-510)

Prior to this commit, Android-only PRs were silently triggering 14 unrelated Spring Boot matrix jobs (up to 45 min each). This commit fixes that by adding missing PR filters for all Android directories, letting us skip Spring Boot CI entirely when nothing Spring-related changes.

Note: Every push to main still runs the full matrix.

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .github/workflows/spring-boot-2-matrix.yml | 6 ++++--
 .github/workflows/spring-boot-3-matrix.yml | 6 ++++--
 .github/workflows/spring-boot-4-matrix.yml | 6 ++++--
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 38aaacec27a..9a69765657c 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -4,9 +4,11 @@ on:
   push:
     branches:
       - main
-    paths-ignore:
-      - '**/sentry-android/**'
   pull_request:
+    paths-ignore:
+      - '*android*/**'
+      - 'sentry-compose/**'
+      - 'sentry-samples/sentry-samples-android/**'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 629535e282d..c6a83c597fb 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -4,9 +4,11 @@ on:
   push:
     branches:
       - main
-    paths-ignore:
-      - '**/sentry-android/**'
   pull_request:
+    paths-ignore:
+      - '*android*/**'
+      - 'sentry-compose/**'
+      - 'sentry-samples/sentry-samples-android/**'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index bbd4f986d96..93d314de2e3 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -4,9 +4,11 @@ on:
   push:
     branches:
       - main
-    paths-ignore:
-      - '**/sentry-android/**'
   pull_request:
+    paths-ignore:
+      - '*android*/**'
+      - 'sentry-compose/**'
+      - 'sentry-samples/sentry-samples-android/**'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

From 93590c466b71c92baddd217c6af595be6a897647 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Thu, 21 May 2026 12:04:57 +0200
Subject: [PATCH 165/391] chore(ci): Skip backend system tests when updating
 Android modules (#5455)

chore(ci): Stop backend system tests from running on Android-only PRs (JAVA-519)

Prior to this commit, Android-only PRs were silently triggering 24 unrelated backend system test jobs (up to 10 min each). This update lets us skip those jobs when we don't need them.

Note: Every push to main still runs the full matrix.

---------

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 .github/workflows/system-tests-backend.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 007fe575d14..ea6a53a8750 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -5,6 +5,10 @@ on:
     branches:
       - main
   pull_request:
+    paths-ignore:
+      - '*android*/**'
+      - 'sentry-compose/**'
+      - 'sentry-samples/sentry-samples-android/**'
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

From c3ee041489d813b39609501374678f04b3e4677f Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Thu, 21 May 2026 12:52:12 +0200
Subject: [PATCH 166/391] chore(ai): Add check-code-attribution skill
 (JAVA-499) (#5449)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

chore(ai): Add check-code-attribution skill (JAVA-499)

Adds a check-code-attribution skill that validates license headers + THIRD_PARTY_NOTICES.md entries for code copied or adapted from third parties. Also verifies license compatiblity against Sentry's licensing policy.

Focus is limited to the branch diff. Reports any issues found via PR comments (when run on CI) or to the terminal (when run locally).

To run it in Claude Code:

 ```
 /check-code-attribution
 ```

Runs on CI automatically via [Warden](https://warden.sentry.dev/).

- Purely advisory / does not block merge.
- Generates PR comments with code suggestions for all discovered issues.
- Automatically manages removing stale comments as PRs are updated.

Current Warden configs:

  ┌─────────────────┬─────────────────────────────┬───────────────────────────────────────────────────┐
  │     Setting     │            Value            │                      Effect                       │
  ├─────────────────┼─────────────────────────────┼───────────────────────────────────────────────────┤
  │ model           │ anthropic/claude-sonnet-4-6 │ Model used for analysis                           │
  ├─────────────────┼─────────────────────────────┼───────────────────────────────────────────────────┤
  │ maxTurns        │ 30                          │ Max tool calls per chunk                          │
  ├─────────────────┼─────────────────────────────┼───────────────────────────────────────────────────┤
  │ skill           │ check-code-attribution      │ Per-file vendored code attribution check          │
  ├─────────────────┼─────────────────────────────┼───────────────────────────────────────────────────┤
  │ failOn          │ off                         │ Do not fail workflow if attribution issues found  │
  ├─────────────────┼─────────────────────────────┼───────────────────────────────────────────────────┤
  │ reportOn        │ medium                      │ Show findings at >= medium severity via PR comment│
  ├─────────────────┼─────────────────────────────┼───────────────────────────────────────────────────┤
  │ requestChanges  │ false                       │ Never post REQUEST_CHANGES comments on PRs        │
  ├─────────────────┼─────────────────────────────┼───────────────────────────────────────────────────┤
  │ failCheck       │ false                       │ No red X on workflow in GitHub UI if it fails     │
  ├─────────────────┼─────────────────────────────┼───────────────────────────────────────────────────┤
  │ triggers        │ pull_request + local        │ Runs on PR open/sync and local warden invocations │
  ├─────────────────┼─────────────────────────────┼───────────────────────────────────────────────────┤
  │ reportOnSuccess │ false (default)             │ No comment when everything is clean               │
  └─────────────────┴─────────────────────────────┴───────────────────────────────────────────────────┘

Going forward, we can consider blocking PRs once we've had a chance to vet behavior in the wild.
---
 .claude/skills/.gitignore                     |   2 +
 .../skills/check-code-attribution/SKILL.md    | 244 +++++++++++
 .../validation-tests/EXPECTED.json            |  53 +++
 .../validation-tests/README.md                |  86 ++++
 .../THIRD_PARTY_NOTICES.catalog.md            | 130 ++++++
 .../validation-tests/assert-scenarios.mjs     | 401 ++++++++++++++++++
 .../check-code-attribution-tests.sh           | 246 +++++++++++
 .../HeaderCompleteAndNoticePresent.java       |  19 +
 .../HeaderCompleteButNoticeMissing.java       |  17 +
 .../scenarios/HeaderFullyStripped.java        |   7 +
 .../HeaderMissingButNoticePresent.java        |   8 +
 .../HeaderMissingNonEssentialInfo.java        |  12 +
 .../scenarios/HeaderPartiallyStripped.java    |  10 +
 .../scenarios/NewLicenseType.java             |  10 +
 .../THIRD_PARTY_NOTICES.mismatch-snippet.md   |  37 ++
 .gitignore                                    |   3 +
 AGENTS.md                                     |   2 +
 agents.toml                                   |   4 +
 warden.toml                                   | 101 +++++
 19 files changed, 1392 insertions(+)
 create mode 100644 .claude/skills/check-code-attribution/SKILL.md
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/EXPECTED.json
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/README.md
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/THIRD_PARTY_NOTICES.catalog.md
 create mode 100755 .claude/skills/check-code-attribution/validation-tests/assert-scenarios.mjs
 create mode 100755 .claude/skills/check-code-attribution/validation-tests/check-code-attribution-tests.sh
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/scenarios/HeaderCompleteAndNoticePresent.java
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/scenarios/HeaderCompleteButNoticeMissing.java
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/scenarios/HeaderFullyStripped.java
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/scenarios/HeaderMissingButNoticePresent.java
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/scenarios/HeaderMissingNonEssentialInfo.java
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/scenarios/HeaderPartiallyStripped.java
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/scenarios/NewLicenseType.java
 create mode 100644 .claude/skills/check-code-attribution/validation-tests/scenarios/THIRD_PARTY_NOTICES.mismatch-snippet.md
 create mode 100644 warden.toml

diff --git a/.claude/skills/.gitignore b/.claude/skills/.gitignore
index 229f4495ee3..2dd55eba801 100644
--- a/.claude/skills/.gitignore
+++ b/.claude/skills/.gitignore
@@ -8,3 +8,5 @@
 !test/**
 !btrace-perfetto/
 !btrace-perfetto/**
+!check-code-attribution/
+!check-code-attribution/**
diff --git a/.claude/skills/check-code-attribution/SKILL.md b/.claude/skills/check-code-attribution/SKILL.md
new file mode 100644
index 00000000000..ee66327c260
--- /dev/null
+++ b/.claude/skills/check-code-attribution/SKILL.md
@@ -0,0 +1,244 @@
+---
+name: check-code-attribution
+description: Per-file check of vendored code attribution in the current branch diff, including license headers, THIRD_PARTY_NOTICES.md entries, and compatibility with Sentry's licensing policy
+allowed-tools: Bash Read Grep Glob
+---
+
+# Check Code Attribution
+
+You are reviewing changed files for third-party code attribution compliance in **sentry-java**, an MIT-licensed repository.
+
+## Local runs
+
+When running locally (not via Warden), review every file changed on this branch vs the base branch. Apply the same path exclusions as `ignorePaths` in `warden.toml`, then run Quick triage and the checks below on each file. For git commands to list changed files and Warden CLI setup, see `validation-tests/README.md`. `/check-code-attribution` in the IDE does not require Warden credentials.
+
+When running via Warden, the changed file is already provided — skip branch-wide discovery, but follow **Warden execution** below.
+
+## Warden execution
+
+Warden analyzes one changed file per run (whole-file mode). Complete every Quick triage step — the diff alone is not sufficient.
+
+**Mandatory on every run (do not skip):**
+
+1. Read the first 50 lines of the changed file.
+2. Search `THIRD_PARTY_NOTICES.md` for the class name (filename without extension, e.g. `ANRWatchDog` for `ANRWatchDog.java`). On renames, also search for the old basename and read Scope sections (see Quick triage).
+3. When you can compare against the base branch version, inspect the header at that revision (first 50 lines).
+
+**Do not dismiss findings because:**
+
+- A `THIRD_PARTY_NOTICES.md` entry exists — file headers are still required; NOTICES does not replace them.
+- The diff only removes a header comment block — if removed `-` lines include a **required field** (see below) or vendoring language ("adapted from", etc.), attribution was stripped. Removing boilerplate alone is not stripping.
+- The header says "Adapted from …" but omits copyright holder or license name — flag missing header fields.
+- The file header has all four required fields — a missing THIRD_PARTY_NOTICES.md entry is independently required and is ⚠️ medium regardless of header completeness.
+
+For `THIRD_PARTY_NOTICES.md` runs: for every **removed** entry in the diff, confirm whether Scope files still exist with attribution headers. If they do, the entry must not be removed.
+
+## Quick triage
+
+Sentry's own files carry **no** copyright headers — any copyright/license line indicates third-party code. Every file that reaches this skill is in scope — do not skip files based on extension.
+
+If this file is `THIRD_PARTY_NOTICES.md`, go to the THIRD_PARTY_NOTICES section below.
+
+For all other files, perform these checks **before** deciding whether to proceed:
+
+1. **Read the file header** — inspect the first 50 lines. Look for vendored-code signals: `Copyright`, `Licensed under`, `SPDX-License-Identifier`, or vendoring language ("adapted from", "backported from", "based on", "copied from", "derived from", "inspired by", "ported from", "translated from", "vendored").
+2. **Check THIRD_PARTY_NOTICES.md** — search for the file name without extension (e.g. `ANRWatchDog` when reviewing `ANRWatchDog.java`). A match means this is a known vendored file. **Renames:** if the diff is a rename (`similarity index` / `rename from` in the diff, or a delete of one path and add of another with the same content), also search for the **old** basename and read **Scope** sections in matching entries — NOTICES may still reference the previous class or path name.
+    > **A complete NOTICES entry does NOT end the check.** It confirms the file is vendored and that the NOTICES requirement is satisfied. The file header is a separate, additional requirement — continue to header verification regardless of NOTICES completeness.
+3. **Scan the diff** — check for vendored-code signals on both added (`+`) and **removed (`-`)** lines. Removed lines that drop a **required field** (copyright, license name, source URL, vendoring origin) ARE signals. Removed disclaimer/boilerplate lines alone are not.
+
+**A signal in ANY of these three sources means this is vendored code — proceed to the vendored source file section.**
+
+A file referenced in THIRD_PARTY_NOTICES.md is ALWAYS vendored, even if its current header has no attribution.
+
+**If none of the three sources have signals, report no findings and stop.**
+
+---
+
+## If this file is `THIRD_PARTY_NOTICES.md`
+
+Validate the changed entries using the diff context:
+
+1. For each added or modified entry, verify it has all required fields: **Source URL**, **License name**, **Copyright**, **Scope** (file paths), and **full license text** in a fenced code block.
+2. For each Scope path, verify the file(s) exist.
+3. Flag new license types using the same license-tier table as for source files: weak copyleft (LGPL, MPL, EPL) → 🚨 **high**, strong copyleft (GPL) → 🚨 **high**, AGPL → 🚨 **high** (absolute ban, must be removed). Do not use low or medium for copyleft or AGPL.
+4. Flag orphaned entries whose Scope files no longer exist.
+5. For **removed** entries (lines prefixed with `-` in the diff), check whether the Scope files still exist and still have attribution headers. If they do, the entry must not be removed.
+6. Check **copyright consistency** — the Copyright field must match the copyright line inside the embedded license text. Flag mismatches.
+
+---
+
+## If this is a vendored file
+
+### 1. Check attribution header
+
+Check each of the following by reading the file header — not NOTICES. Each is an independent yes/no; a "no" is ⚠️ medium regardless of NOTICES completeness:
+
+- [ ] **Vendoring origin phrase** — explicit wording such as `Adapted from …`, `Based on …`, `Vendored from …`, or a library name.
+- [ ] **Copyright line** — e.g. `Copyright (c) 2016 …`, `Copyright 2010 Square, Inc.`
+- [ ] **License name** — e.g. `Licensed under the Apache License, Version 2.0`, `The MIT License`
+- [ ] **Source URL** — e.g. `https://github.com/…`
+
+Exact wording and comment style may vary. **Do not flag** missing or changed content that is not one of these four fields.
+
+**Each field must be physically present in the file header. A complete `THIRD_PARTY_NOTICES.md` entry does not satisfy any required field — both are independently required. Check each of the four fields by reading the file header, not by reasoning from NOTICES.**
+
+**Not required in the file header** (full text belongs in `THIRD_PARTY_NOTICES.md`, not in every source file):
+
+- Full license boilerplate (MIT permission paragraph, Apache "Unless required by applicable law…" disclaimer, ASF contributor grant preamble)
+- Wording differences vs the NOTICES embedded license text (e.g. shortened Apache header vs canonical ASF phrasing)
+- Comment style (`//` vs `/* */`), line wrapping, or extra Sentry modification notes
+
+Compare the current header against the NOTICES entry **only for the four required fields** — e.g. if NOTICES says MIT by "Salomon BRYS" but the header has no copyright or license name, flag it. If both have copyright + license name but the header omits the Apache disclaimer while NOTICES still has the full text, **do not flag**.
+
+When comparing against the base branch version (local runs), use the header at that revision for additional context.
+
+Flag these issues:
+- **Header stripped** — file is in NOTICES but current header has none of the four required fields
+- **Header truncated** — one or more **required** fields were removed (e.g. copyright line or `Licensed under …` removed) while the file remains vendored
+- **Header inconsistent** — a **required** field contradicts NOTICES (wrong copyright holder/year, wrong license name) — not boilerplate or phrasing differences
+- **Diff removes required attribution** — removed `-` lines drop a required field or vendoring origin (`Adapted from`, etc.); removing disclaimer/boilerplate lines alone is **not** this
+
+**Do not report** (no finding — prefer silence):
+
+- Apache/MIT disclaimer or permission paragraphs removed but all four required fields remain
+- Header reworded to a shorter permissive-license form with the same copyright holder and license name
+- Header and NOTICES differ only in full license body text (wording or boilerplate, not missing required fields)
+
+These exceptions apply only when an entry already exists in NOTICES and only to header-vs-NOTICES wording differences. A **missing** NOTICES entry is ⚠️ medium per section 2 — never covered by these exceptions.
+
+### 2. Check THIRD_PARTY_NOTICES.md entry
+
+**Severity: always `medium`. Do not output `severity: "low"` for a missing entry even if the attribution header is complete.**
+
+`THIRD_PARTY_NOTICES.md` is a mandatory legal exhibit that Sentry ships with every SDK distribution. It must enumerate all vendored code regardless of what the source file header says. A missing entry is a distribution-level compliance failure, not a nit. A complete file header does not satisfy the NOTICES requirement — both are mandatory.
+
+From the NOTICES search in Quick triage: if no matching entry exists, output `severity: "medium"` and flag as ⚠️ Missing THIRD_PARTY_NOTICES.md entry. A valid entry needs: Source URL, License name, Copyright, Scope, full license text.
+
+### 3. Check license compatibility
+
+Classify the license per Sentry's Open Source Legal Policy (https://open.sentry.io/licensing/):
+
+| Tier            | Examples                                        | Finding                                     |
+|-----------------|-------------------------------------------------|---------------------------------------------|
+| Permissive      | MIT, BSD, Apache 2.0, ISC, CC0, Unlicense, Zlib | None — license is compatible                |
+| Weak copyleft   | LGPL, MPL, EPL, CDDL                            | 🚨 **high** — requires review               |
+| Strong copyleft | GPL, QPL, Sleepycat, OSL                        | 🚨 **high** — requires legal review         |
+| AGPL            | —                                               | 🚨 **high** — absolute ban, must be removed |
+| No license      | —                                               | 🚨 **high** — assume no permission          |
+
+**Permissive licenses:** do not report a finding solely because the license is MIT/BSD/Apache/etc. Only flag missing or stripped **required** header fields, or missing/inconsistent `THIRD_PARTY_NOTICES.md` entry. Do not flag disclaimer/boilerplate-only diffs. Copyleft and unlicensed code still get 🚨 findings per the table.
+
+---
+
+## If this is a deleted vendored file
+
+If the diff deletes a file and the removed lines contained attribution headers, check whether `THIRD_PARTY_NOTICES.md` still references it — the entry should be updated or removed.
+
+---
+
+## Severity guide
+
+| Level      | Use for                                                                                                                                                                                     |
+|------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **high**   | 🚨 License violations: AGPL, copyleft, unlicensed, no-license code                                                                                                                          |
+| **medium** | ⚠️ Missing **required** header fields, stripped required fields, missing/inconsistent NOTICES entries (even when header is complete), deleted/renamed vendored files needing NOTICES update |
+| **low**    | 👀 Cosmetic/style differences only (shortened license wording, comment style). **Never** use for a missing NOTICES entry or missing header field — those are always medium.                 |
+
+Warden relies on these severity levels when deciding whether to comment on PRs or require changes. Put the severity emoji **only on the finding title** (see Output) so reviewers can triage at a glance.
+
+## Output
+
+**No issues → empty response (say nothing).**
+
+Otherwise, report each finding ordered by severity (most severe first).
+
+### Emoji placement (required)
+
+Use the emoji from the severity guide (🚨, ⚠️, or 👀) — not the word `high`, `medium`, or `low`.
+
+| Field             | Emoji?                   | Example                                                                                                                                |
+|-------------------|--------------------------|----------------------------------------------------------------------------------------------------------------------------------------|
+| **Title**         | Yes — once, at the start | `⚠️ Copyright line stripped from vendored file header`                                                                                 |
+| **Description**   | **No**                   | `**io.sentry.cache.tape.FileObjectQueue** — The Copyright (C) 2010 Square, Inc. line was removed…` (see **Description subject** below) |
+| **Verification**  | **No**                   | Evidence steps only                                                                                                                    |
+| **Suggested fix** | **No**                   | Fix text only                                                                                                                          |
+
+**Good (Warden PR comment):**
+
+```
+Title:       ⚠️ Copyright line stripped from vendored file header
+Description: **io.sentry.cache.tape.FileObjectQueue** — The `Copyright (C) 2010 Square, Inc.` line was removed from this vendored file's header. Please restore the copyright line.
+```
+
+**Bad — emoji in the description (never do this):**
+
+```
+Title:       ⚠️ Copyright line stripped from vendored file header
+Description: ⚠️ The `Copyright (C) 2010 Square, Inc.` line was removed…
+```
+
+**Bad — emoji before the class name:**
+
+```
+Title:       ⚠️ Copyright line stripped from vendored file header
+Description: ⚠️ **io.sentry.cache.tape.FileObjectQueue** — The copyright line was removed…
+```
+
+### Description subject (required)
+
+Every description **must** start with `**<subject>** —` (bold subject, space, em dash, space). Pick **one** subject by file type:
+
+| File type                                                                                 | Subject format                                                       | Example                                                        |
+|-------------------------------------------------------------------------------------------|----------------------------------------------------------------------|----------------------------------------------------------------|
+| Java / Kotlin source (`.java`, `.kt`) with a top-level type                               | Fully qualified class name (FQCN)                                    | `**io.sentry.CircularFifoQueue** —`                            |
+| Java / Kotlin with no single clear type (multiple top-level types, unclear which changed) | FQCN of the primary type under review, or repo-relative path if none | `**sentry/src/.../Foo.kt** —`                                  |
+| `THIRD_PARTY_NOTICES.md`                                                                  | `THIRD_PARTY_NOTICES.md — <entry heading>`                           | `**THIRD_PARTY_NOTICES.md — Square — Seismic (Apache 2.0)** —` |
+| Gradle / other scripts (e.g. `.kts`, `.gradle`)                                           | Repo-relative path from repository root                              | `**build.gradle.kts** —`                                       |
+
+- Prefer **FQCN** for `.java` / `.kt` vendored source (derive from `package` + primary public top-level class). Do not use file paths when a FQCN is clear.
+- For license-tier / policy issues, include https://open.sentry.io/licensing/ in the description body.
+
+### Warden runs
+
+For each finding, set these fields exactly:
+
+| Field            | Value                                                                                                             |
+|------------------|-------------------------------------------------------------------------------------------------------------------|
+| **severity**     | `high`, `medium`, or `low` — **never** put emoji here; Warden maps severity from this field, not from the title   |
+| **title**        | `<severity emoji> <short issue title>` — emoji allowed **only** here (imperative, no class name)                  |
+| **description**  | `**<subject>** — <what is wrong and how to fix>` — **plain text only**; subject per **Description subject** above |
+| **verification** | Optional evidence steps — plain text only                                                                         |
+
+**Description rules (Warden):**
+
+- **Must** match `**<subject>** — …` using the table in **Description subject**.
+- **Must not** contain 🚨, ⚠️, 👀, or the words `high`, `medium`, or `low` as severity labels.
+- **Must not** repeat the title or paraphrase it with an emoji prefix.
+
+**Good (NOTICES entry removed while scope files remain):**
+
+```
+Title:       ⚠️ NOTICES entry removed for vendored code still in tree
+Description: **THIRD_PARTY_NOTICES.md — Square — Seismic (Apache 2.0)** — The Seismic entry was removed but `io.sentry.android.core.SentryShakeDetector` still has an attribution header. Restore the entry or remove attribution from the scope files.
+```
+
+**Before submitting findings:** For every finding, confirm `description` does not match `[🚨⚠️👀]` and matches `^\*\*.+\*\* — `. If it contains any emoji, rewrite the description without it.
+
+### Local / IDE runs
+
+Use this numbered format — same title vs description split as above:
+
+```
+1\. <severity emoji> **<short issue title>**
+   **<subject>** — <what's wrong and how to fix it — one or two lines>
+
+2\. <severity emoji> **<short issue title>**
+   **<subject>** — <what's wrong and how to fix it — one or two lines>
+```
+
+Rules:
+
+- Put the severity emoji **only** on the title line (`1\. ⚠️ **…**`), never on the description line.
+- The description line uses `**<subject>** —` per **Description subject** and must not contain 🚨, ⚠️, or 👀.
+- **Escape the period** after the number (`1\.` not `1.`) so markdown does not collapse entries into a tight list.
+- Leave an empty line between each numbered finding.
diff --git a/.claude/skills/check-code-attribution/validation-tests/EXPECTED.json b/.claude/skills/check-code-attribution/validation-tests/EXPECTED.json
new file mode 100644
index 00000000000..a82637b84e2
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/EXPECTED.json
@@ -0,0 +1,53 @@
+[
+  {
+    "id": "header-complete-and-notice-present",
+    "file": "HeaderCompleteAndNoticePresent.java",
+    "expectFinding": false,
+    "notes": "Header matches catalog entry"
+  },
+  {
+    "id": "header-complete-but-notice-missing",
+    "file": "HeaderCompleteButNoticeMissing.java",
+    "expectFinding": true,
+    "isolated": true,
+    "notes": "Full header; no catalog / root NOTICES entry. Isolated: prompt-cache priming in a concurrent batch suppresses the missing-NOTICES finding below medium."
+  },
+  {
+    "id": "header-missing-but-notice-present",
+    "file": "HeaderMissingButNoticePresent.java",
+    "expectFinding": true,
+    "isolated": true,
+    "notes": "NOTICES entry claims file is vendored but file has no attribution header. Isolated: a complete NOTICES entry suppresses the missing-header finding in a concurrent batch."
+  },
+  {
+    "id": "header-fully-stripped",
+    "file": "HeaderFullyStripped.java",
+    "expectFinding": true,
+    "notes": "Header has no required attribution fields"
+  },
+  {
+    "id": "header-partially-stripped",
+    "file": "HeaderPartiallyStripped.java",
+    "expectFinding": true,
+    "notes": "Adapted from + URL only; no copyright or license name"
+  },
+  {
+    "id": "header-missing-non-essential-info",
+    "file": "HeaderMissingNonEssentialInfo.java",
+    "expectFinding": false,
+    "notes": "All four required fields present; no license boilerplate — boilerplate is not required in the header"
+  },
+  {
+    "id": "header-vs-notice-mismatch",
+    "file": "THIRD_PARTY_NOTICES.md",
+    "expectFinding": true,
+    "isolated": true,
+    "notes": "Copyright in metadata field does not match embedded license text. Isolated: mismatch finding needs an independent assertion free of interference from other NOTICES changes."
+  },
+  {
+    "id": "new-license-type",
+    "file": "NewLicenseType.java",
+    "expectFinding": true,
+    "notes": "AGPL v3 license in file header — absolute ban, must be removed"
+  }
+]
diff --git a/.claude/skills/check-code-attribution/validation-tests/README.md b/.claude/skills/check-code-attribution/validation-tests/README.md
new file mode 100644
index 00000000000..99fb42a6836
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/README.md
@@ -0,0 +1,86 @@
+# Attribution skill validation tests
+
+Self-contained samples for validating `check-code-attribution` without touching production SDK sources.
+
+
+## Run the tests
+
+```bash
+./check-code-attribution-tests.sh
+```
+
+Requires Node.js and a Warden provider (see **Warden CLI** below).
+
+In practice, straight command line runs tend to be a bit flakier than asking Claude Code to run the tests for you.
+
+## Local development
+
+### Discovering changed files
+
+When running `/check-code-attribution` outside Warden, list files changed on the current branch vs the base branch, then apply the same exclusions as `ignorePaths` in `warden.toml`:
+
+```bash
+MB=$(git merge-base HEAD origin/main 2>/dev/null || git merge-base HEAD main)
+git diff --name-only "${MB}"..HEAD
+```
+
+### Warden CLI
+
+Warden does **not** use Cursor auth. Before running Warden locally, configure a provider (same model family as `warden.toml`, or override with `-m`):
+
+```bash
+# Option A: Anthropic API key (matches CI model in warden.toml)
+export WARDEN_ANTHROPIC_API_KEY=sk-ant-...   # or: export ANTHROPIC_API_KEY=sk-ant-...
+
+# Option B: Pi OAuth / API key store (~/.pi/agent/auth.json)
+npx pi    # then run /login and pick Anthropic (or another provider)
+
+# Option C: Different provider for a one-off run
+export WARDEN_OPENAI_API_KEY=sk-...
+npx @sentry/warden origin/main..HEAD --skill check-code-attribution -m openai/gpt-5.5 -vv
+```
+
+```bash
+npx @sentry/warden origin/main..HEAD --skill check-code-attribution -vv
+```
+
+## Layout
+
+- `EXPECTED.json` — scenario IDs and expected outcomes (single source of truth).
+- `THIRD_PARTY_NOTICES.catalog.md` — NOTICES-style entries for validation class names.
+- `scenarios/` — `.java` files and `THIRD_PARTY_NOTICES.mismatch-snippet.md` (copyright-mismatch fixture).
+- `check-code-attribution-tests.sh` — runs Warden on a temp branch and asserts per-scenario pass/fail.
+- `assert-scenarios.mjs` — validation driver (`list-isolated`, `routing-set`, `assert` subcommands); parses Warden JSONL and checks outcomes from `EXPECTED.json`.
+
+### assert-scenarios.mjs commands
+
+```bash
+node assert-scenarios.mjs validate EXPECTED.json scenarios/     # pre-flight (no API); run automatically by the shell script
+node assert-scenarios.mjs list-isolated EXPECTED.json           # id<TAB>file per isolated scenario
+node assert-scenarios.mjs list-main-java EXPECTED.json scenarios/  # .java files for the main Warden batch
+node assert-scenarios.mjs routing-set routing.json <id> <path>     # update id → Warden JSONL path
+node assert-scenarios.mjs assert EXPECTED.json <dest-pkg> routing.json
+```
+
+Warden runs are limited to 300s. On macOS the script uses `gtimeout` (from `brew install coreutils`) when available, otherwise GNU `timeout`, otherwise `perl` with `alarm`.
+
+## Add a scenario
+
+1. Add `scenarios/<UniqueClassName>.java`.
+2. Add or omit a catalog entry in `THIRD_PARTY_NOTICES.catalog.md`.
+3. Add an entry to `EXPECTED.json`.
+4. **Isolation (if needed):** If the scenario relies on a finding that could be suppressed by Anthropic prompt-cache priming when analyzed alongside many other files (e.g. a missing-NOTICES entry, or a missing header on a file that has a complete NOTICES entry), add `"isolated": true` to its `EXPECTED.json` entry. The test script creates a dedicated worktree for each isolated scenario automatically — no changes to the script itself are needed.
+
+## Validation (maintainers)
+
+Test samples live under `validation-tests/` and are excluded from normal skill runs via `.claude/**` in `warden.toml`.
+
+```bash
+.claude/skills/check-code-attribution/validation-tests/check-code-attribution-tests.sh
+```
+
+Expected outcomes are in `EXPECTED.json`. The script creates isolated git worktrees, runs Warden with `--report-on medium --json`, and asserts per-scenario pass/fail. Scenarios marked `"isolated": true` in `EXPECTED.json` each get their own worktree to avoid Anthropic prompt-cache priming that can suppress findings below medium in concurrent batches. Exit 0 = all pass.
+
+When manually reviewing a file under `scenarios/`, search `THIRD_PARTY_NOTICES.catalog.md` in addition to root `THIRD_PARTY_NOTICES.md` (Quick triage step 2 in `SKILL.md`).
+
+Non-Java fixtures required by the test script are listed in `REQUIRED_SCENARIO_FIXTURES` in `assert-scenarios.mjs`; pre-flight `validate` fails if any are missing.
diff --git a/.claude/skills/check-code-attribution/validation-tests/THIRD_PARTY_NOTICES.catalog.md b/.claude/skills/check-code-attribution/validation-tests/THIRD_PARTY_NOTICES.catalog.md
new file mode 100644
index 00000000000..478d0b06313
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/THIRD_PARTY_NOTICES.catalog.md
@@ -0,0 +1,130 @@
+# Test THIRD_PARTY_NOTICES catalog (not shipped)
+
+Used only when validating `check-code-attribution` against `validation-tests/scenarios/**`.
+Grep this file in addition to the repository root `THIRD_PARTY_NOTICES.md`.
+
+---
+
+## Example — HeaderFullyStripped (MIT)
+
+**Source:** https://github.com/example/attribution-fixtures<br>
+**License:** MIT License<br>
+**Copyright:** Copyright (c) 2016 Example Author
+
+### Scope
+
+Attribution validation sample. The code resides in `io.sentry.skills.verification.HeaderFullyStripped` (`validation-tests/scenarios/HeaderFullyStripped.java`).
+
+```
+MIT License
+
+Copyright (c) 2016 Example Author
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
+---
+
+## Example — HeaderMissingButNoticePresent (Apache 2.0)
+
+**Source:** https://github.com/example/notices-without-header<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright 2023 Example Corp.
+
+### Scope
+
+Attribution validation sample. The code resides in `io.sentry.skills.verification.HeaderMissingButNoticePresent`.
+
+```
+Copyright 2023 Example Corp.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
+## Example — HeaderMissingNonEssentialInfo (MIT)
+
+**Source:** https://github.com/example/examplelib<br>
+**License:** MIT License<br>
+**Copyright:** Copyright 2020 Example Corp.
+
+### Scope
+
+Attribution validation sample. The code resides in `io.sentry.skills.verification.HeaderMissingNonEssentialInfo`.
+
+```
+MIT License
+
+Copyright (c) 2020 Example Corp.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
+
+---
+
+## Example — HeaderCompleteAndNoticePresent (Apache 2.0)
+
+**Source:** https://github.com/example/something<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright 2020 Example Authors
+
+### Scope
+
+Attribution validation sample. The code resides in `io.sentry.skills.verification.HeaderCompleteAndNoticePresent`.
+
+```
+Copyright 2020 Example Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
diff --git a/.claude/skills/check-code-attribution/validation-tests/assert-scenarios.mjs b/.claude/skills/check-code-attribution/validation-tests/assert-scenarios.mjs
new file mode 100755
index 00000000000..3ff4cce9980
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/assert-scenarios.mjs
@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+/**
+ * Validation driver for check-code-attribution scenario tests.
+ *
+ * Usage:
+ *   node assert-scenarios.mjs validate <EXPECTED.json> <scenarios-dir>
+ *   node assert-scenarios.mjs list-isolated <EXPECTED.json>
+ *   node assert-scenarios.mjs list-main-java <EXPECTED.json> <scenarios-dir>
+ *   node assert-scenarios.mjs routing-set <routing.json> <id> <jsonl-path>
+ *   node assert-scenarios.mjs assert <EXPECTED.json> <dest-package-path> <routing.json>
+ *
+ * routing.json maps scenario id to Warden JSONL output path, e.g. { "main": "/tmp/..." }.
+ * Non-isolated scenarios use the "main" entry when no dedicated id is present.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const ISOLATED_FILE_JAVA = /\.java$/i;
+const ISOLATED_FILE_NOTICES = 'THIRD_PARTY_NOTICES.md';
+
+/** Non-Java fixtures under scenarios/ that check-code-attribution-tests.sh requires. */
+const REQUIRED_SCENARIO_FIXTURES = [
+  'THIRD_PARTY_NOTICES.mismatch-snippet.md',
+];
+
+export function loadExpected(expectedPath) {
+  return JSON.parse(fs.readFileSync(expectedPath, 'utf8'));
+}
+
+export function listIsolated(scenarios) {
+  return scenarios.filter((s) => s.isolated);
+}
+
+/** Repo-relative path normalization for Warden JSONL matching. */
+export function normalizeRepoPath(filePath) {
+  if (!filePath) return filePath;
+  return filePath.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+/g, '/');
+}
+
+/** True when a Warden-reported path refers to the expected scenario file. */
+export function pathMatchesWardenFile(reportedPath, wardenFile) {
+  const reported = normalizeRepoPath(reportedPath);
+  const expected = normalizeRepoPath(wardenFile);
+  if (reported === expected) return true;
+  const base = expected.split('/').pop();
+  return base != null && reported.endsWith(`/${base}`);
+}
+
+export function findingCountForFile(fileMap, wardenFile) {
+  const expected = normalizeRepoPath(wardenFile);
+  if (fileMap[expected] != null) return fileMap[expected];
+  for (const [key, count] of Object.entries(fileMap)) {
+    if (pathMatchesWardenFile(key, wardenFile)) return count;
+  }
+  return 0;
+}
+
+export function findingsForFile(findings, wardenFile) {
+  return findings.filter(
+    (f) => f.location && pathMatchesWardenFile(f.location.path, wardenFile),
+  );
+}
+
+export function listMainBatchJava(scenarios, scenariosDir) {
+  const isolatedJava = new Set(
+    listIsolated(scenarios)
+      .map((s) => s.file)
+      .filter((file) => ISOLATED_FILE_JAVA.test(file)),
+  );
+  return fs
+    .readdirSync(scenariosDir)
+    .filter((name) => name.endsWith('.java') && !isolatedJava.has(name))
+    .sort();
+}
+
+/**
+ * @returns {string[]} validation error messages (empty = ok)
+ */
+export function validateExpected(scenarios, scenariosDir) {
+  const errors = [];
+
+  if (!Array.isArray(scenarios)) {
+    return ['EXPECTED.json must be a JSON array'];
+  }
+
+  const ids = new Set();
+  const expectedJava = new Set();
+
+  for (const [index, s] of scenarios.entries()) {
+    const label = `entry ${index}`;
+    if (!s || typeof s !== 'object') {
+      errors.push(`${label}: must be an object`);
+      continue;
+    }
+    if (typeof s.id !== 'string' || !s.id) {
+      errors.push(`${label}: missing or empty "id"`);
+    } else {
+      if (ids.has(s.id)) errors.push(`duplicate id "${s.id}"`);
+      ids.add(s.id);
+      if (s.id === 'main') {
+        errors.push(`id "main" is reserved for routing.json`);
+      }
+    }
+    if (typeof s.file !== 'string' || !s.file) {
+      errors.push(`${label}: missing or empty "file"`);
+    } else if (ISOLATED_FILE_JAVA.test(s.file)) {
+      expectedJava.add(s.file);
+      const onDisk = path.join(scenariosDir, s.file);
+      if (!fs.existsSync(onDisk)) {
+        errors.push(`${s.id}: scenarios/${s.file} does not exist`);
+      }
+    } else if (s.file !== ISOLATED_FILE_NOTICES) {
+      errors.push(
+        `${s.id}: unsupported file "${s.file}" (use *.java or ${ISOLATED_FILE_NOTICES})`,
+      );
+    }
+    if (typeof s.expectFinding !== 'boolean') {
+      errors.push(`${s.id ?? label}: "expectFinding" must be a boolean`);
+    }
+    if (s.isolated) {
+      if (
+        !ISOLATED_FILE_JAVA.test(s.file) &&
+        s.file !== ISOLATED_FILE_NOTICES
+      ) {
+        errors.push(
+          `${s.id}: isolated scenarios must use *.java or ${ISOLATED_FILE_NOTICES}`,
+        );
+      }
+    }
+  }
+
+  let diskEntries = [];
+  try {
+    diskEntries = fs.readdirSync(scenariosDir);
+  } catch (e) {
+    errors.push(`cannot read scenarios dir ${scenariosDir}: ${e.message}`);
+    return errors;
+  }
+
+  const diskJava = diskEntries.filter((n) => n.endsWith('.java'));
+  for (const name of diskJava) {
+    if (!expectedJava.has(name)) {
+      errors.push(`scenarios/${name} has no matching entry in EXPECTED.json`);
+    }
+  }
+
+  for (const name of REQUIRED_SCENARIO_FIXTURES) {
+    const onDisk = path.join(scenariosDir, name);
+    if (!fs.existsSync(onDisk)) {
+      errors.push(`scenarios/${name} is required but missing`);
+    }
+  }
+
+  const diskNonJava = diskEntries.filter(
+    (n) => !n.endsWith('.java') && fs.statSync(path.join(scenariosDir, n)).isFile(),
+  );
+  for (const name of diskNonJava) {
+    if (!REQUIRED_SCENARIO_FIXTURES.includes(name)) {
+      errors.push(
+        `scenarios/${name} is not listed in REQUIRED_SCENARIO_FIXTURES (update assert-scenarios.mjs)`,
+      );
+    }
+  }
+
+  if (listMainBatchJava(scenarios, scenariosDir).length === 0) {
+    errors.push('main Warden batch needs at least one non-isolated .java scenario');
+  }
+
+  return errors;
+}
+
+export function parseWardenJsonl(jsonlPath) {
+  /** @type {Record<string, number>} */
+  const fileMap = {};
+  const allFindings = [];
+  try {
+    const raw = fs.readFileSync(jsonlPath, 'utf8').trim();
+    if (!raw) return { fileMap, findings: [] };
+    const records = raw
+      .split('\n')
+      .filter((l) => l.trim())
+      .map((l) => JSON.parse(l));
+    for (const record of records) {
+      const file = record.chunk && record.chunk.file;
+      if (!file) continue;
+      const normalized = normalizeRepoPath(file);
+      const recordFindings = record.findings || [];
+      fileMap[normalized] = (fileMap[normalized] || 0) + recordFindings.length;
+      for (const f of recordFindings) {
+        allFindings.push({
+          ...f,
+          location: f.location || { path: normalized, startLine: 1 },
+        });
+      }
+    }
+  } catch (e) {
+    console.error(
+      'ERROR: Could not parse Warden output from ' + jsonlPath + ':',
+      e.message,
+    );
+    process.exit(2);
+  }
+  return { fileMap, findings: allFindings };
+}
+
+export function routingSet(routingPath, id, jsonlPath) {
+  const routing = JSON.parse(fs.readFileSync(routingPath, 'utf8'));
+  routing[id] = jsonlPath;
+  fs.writeFileSync(routingPath, JSON.stringify(routing));
+}
+
+function wardenFileForScenario(destPkg, scenario) {
+  return scenario.file === ISOLATED_FILE_NOTICES
+    ? ISOLATED_FILE_NOTICES
+    : `${destPkg}/${scenario.file}`;
+}
+
+function loadRouting(routingPath) {
+  /** @type {Record<string, string>} */
+  let routing;
+  try {
+    routing = JSON.parse(fs.readFileSync(routingPath, 'utf8'));
+  } catch (e) {
+    console.error(`ERROR: Could not read routing file ${routingPath}:`, e.message);
+    process.exit(2);
+  }
+
+  if (typeof routing.main !== 'string' || !routing.main) {
+    console.error('ERROR: routing.json must include a non-empty "main" JSONL path.');
+    process.exit(2);
+  }
+  return routing;
+}
+
+function cmdValidate(expectedPath, scenariosDir) {
+  if (!expectedPath || !scenariosDir) {
+    console.error(
+      'Usage: node assert-scenarios.mjs validate <EXPECTED.json> <scenarios-dir>',
+    );
+    process.exit(2);
+  }
+  const errors = validateExpected(loadExpected(expectedPath), scenariosDir);
+  if (errors.length > 0) {
+    console.error('EXPECTED.json validation failed:');
+    for (const err of errors) console.error(`  - ${err}`);
+    process.exit(1);
+  }
+  console.log('EXPECTED.json OK');
+}
+
+function cmdListIsolated(expectedPath) {
+  for (const s of listIsolated(loadExpected(expectedPath))) {
+    process.stdout.write(`${s.id}\t${s.file}\n`);
+  }
+}
+
+function cmdListMainJava(expectedPath, scenariosDir) {
+  if (!expectedPath || !scenariosDir) {
+    console.error(
+      'Usage: node assert-scenarios.mjs list-main-java <EXPECTED.json> <scenarios-dir>',
+    );
+    process.exit(2);
+  }
+  for (const name of listMainBatchJava(loadExpected(expectedPath), scenariosDir)) {
+    process.stdout.write(`${name}\n`);
+  }
+}
+
+function cmdRoutingSet(routingPath, id, jsonlPath) {
+  if (!routingPath || !id || !jsonlPath) {
+    console.error(
+      'Usage: node assert-scenarios.mjs routing-set <routing.json> <id> <jsonl-path>',
+    );
+    process.exit(2);
+  }
+  routingSet(routingPath, id, jsonlPath);
+}
+
+function cmdAssert(expectedPath, destPkg, routingPath) {
+  if (!expectedPath || !destPkg || !routingPath) {
+    console.error(
+      'Usage: node assert-scenarios.mjs assert <EXPECTED.json> <dest-package-path> <routing.json>',
+    );
+    process.exit(2);
+  }
+
+  const routing = loadRouting(routingPath);
+  const scenarios = loadExpected(expectedPath);
+
+  /** @type {Record<string, ReturnType<typeof parseWardenJsonl>>} */
+  const parsed = {};
+  function getSource(id) {
+    const jsonlPath = routing[id] ?? routing.main;
+    if (!parsed[jsonlPath]) parsed[jsonlPath] = parseWardenJsonl(jsonlPath);
+    return parsed[jsonlPath];
+  }
+
+  const GREEN = '\x1b[32m';
+  const RED = '\x1b[31m';
+  const RESET = '\x1b[0m';
+
+  const failures = [];
+  let pass = 0;
+
+  for (const s of scenarios) {
+    if (s.isolated && !routing[s.id]) {
+      console.error(
+        `ERROR: isolated scenario "${s.id}" has no routing entry (missing Warden run?)`,
+      );
+      process.exit(2);
+    }
+
+    const wardenFile = wardenFileForScenario(destPkg, s);
+    const source = getSource(s.id);
+    const count = findingCountForFile(source.fileMap, wardenFile);
+    const passed = s.expectFinding ? count > 0 : count === 0;
+
+    if (passed) {
+      console.log(`${GREEN}PASS${RESET} ${s.id}`);
+      pass++;
+    } else {
+      const reason = s.expectFinding
+        ? 'expected finding (>= medium), got none'
+        : `expected no finding (>= medium), got ${count}`;
+      console.log(`${RED}FAIL${RESET} ${s.id}  (${reason})`);
+
+      failures.push({
+        id: s.id,
+        findings: findingsForFile(source.findings, wardenFile),
+      });
+    }
+  }
+
+  const total = scenarios.length;
+  console.log('');
+  console.log(`${total} scenarios: ${pass} passed, ${total - pass} failed`);
+
+  if (failures.length > 0) {
+    console.log('');
+    console.log('Warden output');
+    console.log('══════════════════════');
+
+    for (const { id, findings } of failures) {
+      console.log('');
+      console.log(id);
+      console.log('-'.repeat(id.length));
+      if (findings.length === 0) {
+        console.log('(Warden produced no findings for this file)');
+      } else {
+        for (const f of findings) {
+          console.log(f.title);
+          if (f.description) console.log(f.description);
+          if (f.verification) console.log('\nVerification: ' + f.verification);
+          console.log('');
+        }
+      }
+    }
+
+    process.exit(1);
+  }
+}
+
+function usage() {
+  console.error(`Usage:
+  node assert-scenarios.mjs validate <EXPECTED.json> <scenarios-dir>
+  node assert-scenarios.mjs list-isolated <EXPECTED.json>
+  node assert-scenarios.mjs list-main-java <EXPECTED.json> <scenarios-dir>
+  node assert-scenarios.mjs routing-set <routing.json> <id> <jsonl-path>
+  node assert-scenarios.mjs assert <EXPECTED.json> <dest-package-path> <routing.json>`);
+  process.exit(2);
+}
+
+function main() {
+  const [, , cmd, ...args] = process.argv;
+  switch (cmd) {
+    case 'validate':
+      cmdValidate(args[0], args[1]);
+      break;
+    case 'list-isolated':
+      if (!args[0]) usage();
+      cmdListIsolated(args[0]);
+      break;
+    case 'list-main-java':
+      cmdListMainJava(args[0], args[1]);
+      break;
+    case 'routing-set':
+      cmdRoutingSet(args[0], args[1], args[2]);
+      break;
+    case 'assert':
+      cmdAssert(args[0], args[1], args[2]);
+      break;
+    default:
+      usage();
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main();
+}
diff --git a/.claude/skills/check-code-attribution/validation-tests/check-code-attribution-tests.sh b/.claude/skills/check-code-attribution/validation-tests/check-code-attribution-tests.sh
new file mode 100755
index 00000000000..090acbe129b
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/check-code-attribution-tests.sh
@@ -0,0 +1,246 @@
+#!/usr/bin/env bash
+# check-code-attribution-tests.sh  —  Validate the check-code-attribution skill against synthetic scenarios.
+#
+# Usage:
+#   ./check-code-attribution-tests.sh [--help]
+#
+# What it does:
+#   1. Validates EXPECTED.json and scenario fixtures (no API calls).
+#   2. Creates an isolated git worktree on a temp branch from HEAD.
+#   3. Creates a diff (non-isolated .java files, NOTICES catalog, mismatch snippet),
+#      commits, and runs Warden on the main batch.
+#   4. Scenarios marked "isolated" in EXPECTED.json each get their own worktree and Warden
+#      run to avoid prompt-cache priming that can suppress findings in concurrent batches.
+#   5. Asserts per-scenario pass/fail against EXPECTED.json (>= medium findings only).
+#   6. Prints Warden's actual output for each failing scenario.
+#   7. Cleans up all worktrees.
+#
+# Requires:
+#   - Node.js / npx
+#   - One of: WARDEN_ANTHROPIC_API_KEY, ANTHROPIC_API_KEY, or Pi OAuth config
+#     (see validation-tests/README.md "Warden CLI" section for setup options)
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/../../../.." && pwd)"
+SCENARIOS_DIR="$SCRIPT_DIR/scenarios"
+CATALOG="$SCRIPT_DIR/THIRD_PARTY_NOTICES.catalog.md"
+EXPECTED_JSON="$SCRIPT_DIR/EXPECTED.json"
+VALIDATION="$SCRIPT_DIR/assert-scenarios.mjs"
+MISMATCH_SNIPPET="$SCENARIOS_DIR/THIRD_PARTY_NOTICES.mismatch-snippet.md"
+
+# Destination path inside the worktree — must not appear in warden.toml ignorePaths.
+DEST_PACKAGE_PATH="sentry/src/test/java/io/sentry/skills/verification"
+
+# Warden wall-clock limit (seconds).
+TIMEOUT_SEC=300
+
+die() { echo "ERROR: $*" >&2; exit 1; }
+
+show_usage() {
+  cat <<'EOF'
+Usage: check-code-attribution-tests.sh [--help]
+
+Validates the check-code-attribution skill against all scenarios in EXPECTED.json.
+Runs Warden on a temporary branch and asserts per-scenario pass/fail (>= medium findings).
+
+Prerequisites:
+  - Node.js (npx)
+  - API key: WARDEN_ANTHROPIC_API_KEY or ANTHROPIC_API_KEY
+    (or Pi OAuth: npx pi && /login — see README.md "Warden CLI" section)
+  - Wall-clock limit: gtimeout (brew install coreutils), GNU timeout, or perl
+EOF
+}
+
+[[ "${1:-}" == "--help" || "${1:-}" == "-h" ]] && { show_usage; exit 0; }
+
+# --- prereq checks ---
+
+command -v node >/dev/null 2>&1 || die "node not found — install Node.js."
+command -v npx >/dev/null 2>&1 || die "npx not found — install Node.js."
+command -v git >/dev/null 2>&1 || die "git not found."
+
+# macOS: GNU timeout is `gtimeout` from coreutils; fall back to perl alarm.
+TIMEOUT_CMD=()
+if command -v gtimeout >/dev/null 2>&1; then
+  TIMEOUT_CMD=(gtimeout "$TIMEOUT_SEC")
+elif command -v timeout >/dev/null 2>&1; then
+  TIMEOUT_CMD=(timeout "$TIMEOUT_SEC")
+elif command -v perl >/dev/null 2>&1; then
+  TIMEOUT_CMD=(perl -e 'alarm shift; exec @ARGV' "$TIMEOUT_SEC")
+else
+  die "Need gtimeout (brew install coreutils), GNU timeout, or perl for Warden wall-clock limit"
+fi
+
+if [[ -z "${WARDEN_ANTHROPIC_API_KEY:-}" && -z "${ANTHROPIC_API_KEY:-}" ]]; then
+  if [[ ! -f "$HOME/.pi/agent/auth.json" ]]; then
+    die "No API key found. Set WARDEN_ANTHROPIC_API_KEY, ANTHROPIC_API_KEY, or run: npx pi && /login"
+  fi
+fi
+
+node "$VALIDATION" validate "$EXPECTED_JSON" "$SCENARIOS_DIR"
+
+# --- cleanup tracking ---
+
+declare -a WORKTREES=()
+declare -a BRANCHES=()
+declare -a JSON_FILES=()
+
+cleanup() {
+  for wt in "${WORKTREES[@]+"${WORKTREES[@]}"}"; do
+    git -C "$REPO_ROOT" worktree remove --force "$wt" 2>/dev/null || true
+  done
+  for b in "${BRANCHES[@]+"${BRANCHES[@]}"}"; do
+    git -C "$REPO_ROOT" branch -D "$b" 2>/dev/null || true
+  done
+  (( ${#JSON_FILES[@]} )) && rm -f "${JSON_FILES[@]}"
+}
+trap cleanup EXIT
+
+# --- resolve base commit ---
+# Branch from HEAD so the worktree includes the current skill definition.
+
+BASE=$(git -C "$REPO_ROOT" rev-parse HEAD || die "Cannot resolve HEAD.")
+TS=$(date +%s)
+
+# --- helpers ---
+
+# Commits paths in a validation worktree with consistent author metadata.
+# Usage: git_commit_in_worktree <worktree> <message> [path...]
+git_commit_in_worktree() {
+  local worktree="$1" message="$2"
+  shift 2
+  if (($# > 0)); then
+    git -C "$worktree" add "$@"
+  fi
+  git -C "$worktree" \
+      -c user.email="ci@sentry.io" \
+      -c user.name="Validation Test" \
+      commit --quiet -m "$message"
+}
+
+# Creates a git worktree from $BASE and commits the NOTICES catalog as the Warden
+# analysis base — so only fixture changes appear in the diff Warden analyzes.
+# Prints the catalog-commit SHA to stdout.
+setup_catalog_base() {
+  local worktree="$1" branch="$2"
+  git -C "$REPO_ROOT" worktree add --quiet "$worktree" "$BASE" -b "$branch"
+  printf '\n' >> "$worktree/THIRD_PARTY_NOTICES.md"
+  sed "s|validation-tests/scenarios/|${DEST_PACKAGE_PATH}/|g" \
+      "$CATALOG" >> "$worktree/THIRD_PARTY_NOTICES.md"
+  git_commit_in_worktree "$worktree" "test: apply NOTICES catalog [skip ci]" \
+      THIRD_PARTY_NOTICES.md
+  git -C "$worktree" rev-parse HEAD
+}
+
+# Appends the mismatch snippet to THIRD_PARTY_NOTICES.md, stripping the fixture's
+# prose header so only the NOTICES entry itself lands in the file.
+append_mismatch_snippet() {
+  local worktree="$1"
+  printf '\n' >> "$worktree/THIRD_PARTY_NOTICES.md"
+  sed '1,/^---$/d' "$MISMATCH_SNIPPET" >> "$worktree/THIRD_PARTY_NOTICES.md"
+}
+
+# Runs Warden and writes JSON output to the given file.
+run_warden() {
+  local base="$1" worktree="$2" json_out="$3" label="$4"
+  echo "Running Warden on ${base:0:7}..HEAD ($label)..."
+  : > "$json_out"
+  if ! "${TIMEOUT_CMD[@]}" npx @sentry/warden "${base}..HEAD" \
+      --skill check-code-attribution \
+      --fail-on off \
+      --report-on medium \
+      --json \
+      -C "$worktree" \
+      > "$json_out"; then
+    if [[ ! -s "$json_out" ]]; then
+      die "Warden failed for $label with no JSON output (check API key, network, and Warden logs)."
+    fi
+    die "Warden exited with an error for $label but left partial JSON in $json_out."
+  fi
+  [[ -s "$json_out" ]] || die "Warden succeeded but produced no JSON output for $label."
+}
+
+# --- main worktree: non-isolated scenarios ---
+# Isolated .java files are omitted here; they get dedicated worktrees below.
+
+echo "Creating worktrees from $(git -C "$REPO_ROOT" rev-parse --short "$BASE")..."
+echo ""
+
+MAIN_WORKTREE=$(mktemp -d)
+MAIN_BRANCH="validation-main-${TS}"
+MAIN_JSON=$(mktemp)
+ROUTING_JSON_FILE=$(mktemp)
+echo '{}' > "$ROUTING_JSON_FILE"
+WORKTREES+=("$MAIN_WORKTREE")
+BRANCHES+=("$MAIN_BRANCH")
+JSON_FILES+=("$MAIN_JSON" "$ROUTING_JSON_FILE")
+
+MAIN_BASE=$(setup_catalog_base "$MAIN_WORKTREE" "$MAIN_BRANCH")
+
+DEST_DIR="$MAIN_WORKTREE/$DEST_PACKAGE_PATH"
+mkdir -p "$DEST_DIR"
+
+shopt -s nullglob
+copied=0
+while IFS= read -r java_file; do
+  cp "$SCENARIOS_DIR/$java_file" "$DEST_DIR/"
+  copied=$((copied + 1))
+done < <(node "$VALIDATION" list-main-java "$EXPECTED_JSON" "$SCENARIOS_DIR")
+echo "Copied ${copied} scenario files → $DEST_PACKAGE_PATH/ (non-isolated batch)"
+append_mismatch_snippet "$MAIN_WORKTREE"
+git_commit_in_worktree "$MAIN_WORKTREE" \
+    "test: add check-code-attribution validation fixtures [skip ci]" \
+    "$DEST_PACKAGE_PATH" THIRD_PARTY_NOTICES.md
+
+run_warden "$MAIN_BASE" "$MAIN_WORKTREE" "$MAIN_JSON" "main"
+node "$VALIDATION" routing-set "$ROUTING_JSON_FILE" main "$MAIN_JSON"
+
+# --- isolated worktrees: one per scenario marked "isolated" in EXPECTED.json ---
+#
+# Scenarios where Anthropic prompt-cache priming can suppress findings in a concurrent
+# batch get their own worktree and Warden run. EXPECTED.json is the single source of
+# truth for which scenarios need isolation — add "isolated": true there, not here.
+# Java isolates omit the mismatch snippet; the NOTICES mismatch scenario adds it alone.
+
+while IFS=$'\t' read -r id file; do
+  worktree=$(mktemp -d)
+  branch="validation-isolated-${TS}-${id//[^a-zA-Z0-9]/-}"
+  json=$(mktemp)
+  WORKTREES+=("$worktree")
+  BRANCHES+=("$branch")
+  JSON_FILES+=("$json")
+
+  base=$(setup_catalog_base "$worktree" "$branch")
+
+  commit_paths=()
+  if [[ "$file" == *.java ]]; then
+    dest_dir="$worktree/$DEST_PACKAGE_PATH"
+    mkdir -p "$dest_dir"
+    cp "$SCENARIOS_DIR/$file" "$dest_dir/"
+    commit_paths=("$DEST_PACKAGE_PATH")
+  elif [[ "$file" == "THIRD_PARTY_NOTICES.md" ]]; then
+    append_mismatch_snippet "$worktree"
+    commit_paths=(THIRD_PARTY_NOTICES.md)
+  else
+    die "Unsupported isolated scenario file: $file (id: $id)"
+  fi
+
+  git_commit_in_worktree "$worktree" "test: isolated fixture for $id [skip ci]" \
+      "${commit_paths[@]}"
+
+  echo ""
+  run_warden "$base" "$worktree" "$json" "$id"
+  node "$VALIDATION" routing-set "$ROUTING_JSON_FILE" "$id" "$json"
+
+done < <(node "$VALIDATION" list-isolated "$EXPECTED_JSON")
+
+echo ""
+echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+# --- assert per-scenario ---
+#
+# ROUTING_JSON_FILE maps scenario id → Warden JSONL path; non-isolated scenarios use "main".
+
+node "$VALIDATION" assert "$EXPECTED_JSON" "$DEST_PACKAGE_PATH" "$ROUTING_JSON_FILE"
diff --git a/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderCompleteAndNoticePresent.java b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderCompleteAndNoticePresent.java
new file mode 100644
index 00000000000..63727be1d5c
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderCompleteAndNoticePresent.java
@@ -0,0 +1,19 @@
+/*
+ * Adapted from https://github.com/example/something
+ *
+ * Copyright 2020 Example Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ */
+package io.sentry.skills.verification;
+
+public final class HeaderCompleteAndNoticePresent {
+
+  public int sum(int a, int b) {
+    return a + b;
+  }
+}
diff --git a/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderCompleteButNoticeMissing.java b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderCompleteButNoticeMissing.java
new file mode 100644
index 00000000000..081d1848300
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderCompleteButNoticeMissing.java
@@ -0,0 +1,17 @@
+/*
+ * Adapted from https://github.com/example
+ *
+ * Copyright 2024 Example Authors
+ *
+ * Licensed under the MIT License
+ *
+ * https://github.com/example/something
+ */
+package io.sentry.skills.verification;
+
+public final class HeaderCompleteButNoticeMissing {
+
+  public boolean ok() {
+    return true;
+  }
+}
diff --git a/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderFullyStripped.java b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderFullyStripped.java
new file mode 100644
index 00000000000..6973848c61e
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderFullyStripped.java
@@ -0,0 +1,7 @@
+/* Attribution stripped — fixture for check-code-attribution validation only. */
+package io.sentry.skills.verification;
+
+public final class HeaderFullyStripped {
+
+  public void run() {}
+}
diff --git a/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderMissingButNoticePresent.java b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderMissingButNoticePresent.java
new file mode 100644
index 00000000000..5c4953ea3ad
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderMissingButNoticePresent.java
@@ -0,0 +1,8 @@
+package io.sentry.skills.verification;
+
+public final class HeaderMissingButNoticePresent {
+
+  public int compute(int x) {
+    return x * 2;
+  }
+}
diff --git a/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderMissingNonEssentialInfo.java b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderMissingNonEssentialInfo.java
new file mode 100644
index 00000000000..c524a2593a4
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderMissingNonEssentialInfo.java
@@ -0,0 +1,12 @@
+// Adapted from ExampleLib.
+// Copyright 2020 Example Corp.
+// Licensed under the MIT License.
+// https://github.com/example/examplelib
+package io.sentry.skills.verification;
+
+public final class HeaderMissingNonEssentialInfo {
+
+  public int compute(int x) {
+    return x + 1;
+  }
+}
diff --git a/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderPartiallyStripped.java b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderPartiallyStripped.java
new file mode 100644
index 00000000000..0389934d94a
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/scenarios/HeaderPartiallyStripped.java
@@ -0,0 +1,10 @@
+// Adapted from Example RateLimiter.
+// https://github.com/example
+package io.sentry.skills.verification;
+
+public final class HeaderPartiallyStripped {
+
+  public synchronized boolean tryAcquire() {
+    return true;
+  }
+}
diff --git a/.claude/skills/check-code-attribution/validation-tests/scenarios/NewLicenseType.java b/.claude/skills/check-code-attribution/validation-tests/scenarios/NewLicenseType.java
new file mode 100644
index 00000000000..e148f5a1a4f
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/scenarios/NewLicenseType.java
@@ -0,0 +1,10 @@
+// Adapted from ExampleLib.
+// Copyright 2020 Example Corp.
+// Licensed under the GNU Affero General Public License v3.0.
+// https://github.com/example/agpl-lib
+package io.sentry.skills.verification;
+
+public final class NewLicenseType {
+
+  public void run() {}
+}
diff --git a/.claude/skills/check-code-attribution/validation-tests/scenarios/THIRD_PARTY_NOTICES.mismatch-snippet.md b/.claude/skills/check-code-attribution/validation-tests/scenarios/THIRD_PARTY_NOTICES.mismatch-snippet.md
new file mode 100644
index 00000000000..5a9b87285df
--- /dev/null
+++ b/.claude/skills/check-code-attribution/validation-tests/scenarios/THIRD_PARTY_NOTICES.mismatch-snippet.md
@@ -0,0 +1,37 @@
+# Snippet fixture — MismatchLib entry for the isolated mismatch worktree.
+# header-vs-notice-mismatch: copyright in metadata field does not match embedded license text.
+
+---
+
+## Example — MismatchLib (MIT)
+
+**Source:** https://github.com/example/mismatch<br>
+**License:** MIT License<br>
+**Copyright:** Copyright (c) 2020 Wrong Holder
+
+### Scope
+
+Validation sample only. The code resides in `io.sentry.skills.verification.MismatchLib`.
+
+```
+MIT License
+
+Copyright (c) 2016 Correct Holder
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+```
diff --git a/.gitignore b/.gitignore
index a7899736a86..f252087a5ab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,3 +37,6 @@ spy.log
 # Auto-generated by dotagents — do not commit these files.
 agents.lock
 .agents/.gitignore
+
+# Warden local run logs
+.warden/logs/
diff --git a/AGENTS.md b/AGENTS.md
index 1784e4f950e..ff50727c662 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -154,6 +154,8 @@ When adapting code from third-party libraries:
    ```
 2. Add a full attribution entry to `THIRD_PARTY_NOTICES.md` following the existing format (Source, License, Copyright, Scope, full license text)
 
+3. Run the `check-code-attribution` skill locally or wait for it to be auto-run against your PR to check for required fields and verify new licenses against [Sentry's Open Source Legal Policy](https://open.sentry.io/licensing/).
+
 ### Getting PR Information
 
 Use `gh pr view` to get PR details from the current branch. This is needed when adding changelog entries, which require the PR number.
diff --git a/agents.toml b/agents.toml
index b4c9e091b70..d9770ee7df5 100644
--- a/agents.toml
+++ b/agents.toml
@@ -35,3 +35,7 @@ source = "path:.agents/skills/test"
 [[skills]]
 name = "btrace-perfetto"
 source = "path:.agents/skills/btrace-perfetto"
+
+[[skills]]
+name = "check-code-attribution"
+source = "path:.agents/skills/check-code-attribution"
diff --git a/warden.toml b/warden.toml
new file mode 100644
index 00000000000..3ce15f9a11f
--- /dev/null
+++ b/warden.toml
@@ -0,0 +1,101 @@
+version = 1
+
+[defaults]
+model = "anthropic/claude-sonnet-4-6"
+
+# Warden's schema does not support per-skill verification config; this is the only
+# placement available. Disabled for attribution policy checks: a second verifier
+# pass often rejects valid header/NOTICES mismatches (e.g. "NOTICES still documents it").
+[defaults.verification]
+enabled = false
+
+# Warden's schema does not support per-skill chunking config; these patterns apply
+# globally but are tuned for check-code-attribution. Attribution checks need the full
+# file header and a NOTICES cross-check — not isolated diff hunks.
+[[defaults.chunking.filePatterns]]
+pattern = "**/*.api"
+mode = "skip"
+
+[[defaults.chunking.filePatterns]]
+pattern = "**/gradlew"
+mode = "skip"
+
+[[defaults.chunking.filePatterns]]
+pattern = "**/gradlew.bat"
+mode = "skip"
+
+[[defaults.chunking.filePatterns]]
+pattern = "**/*.java"
+mode = "whole-file"
+
+[[defaults.chunking.filePatterns]]
+pattern = "**/*.kt"
+mode = "whole-file"
+
+[[defaults.chunking.filePatterns]]
+pattern = "**/*.kts"
+mode = "whole-file"
+
+[[defaults.chunking.filePatterns]]
+pattern = "THIRD_PARTY_NOTICES.md"
+mode = "whole-file"
+
+# Coalesce hunks aggressively for any remaining per-hunk files
+[defaults.chunking.coalesce]
+enabled = true
+maxGapLines = 100
+maxChunkSize = 16000
+
+[[skills]]
+name = "check-code-attribution"
+maxTurns = 30
+# Phase 1: report only — Warden comments on PRs but does not block merges.
+# Tighten to failOn = "medium" / requestChanges = true once the false-positive baseline is established.
+failOn = "off"
+reportOn = "medium"
+ignorePaths = [
+  # Infrastructure directories
+  ".agents/**",
+  ".claude/**",
+  ".cursor/**",
+  ".github/**",
+  ".gradle/**",
+  ".idea/**",
+  ".mvn/**",
+  "gradle/**",
+  # Generated files
+  "**/*.aidl",
+  "**/*.api",
+  "**/*.g.kt",
+  "**/*.interp",
+  "**/*.pb.java",
+  "**/*.tokens",
+  "**/build/**",
+  "**/databinding/*Binding.java",
+  "**/generated/**",
+  "**/gradlew",
+  "**/gradlew.bat",
+  "**/grpc/*Grpc.java",
+  "**/ksp/**",
+  "**/mvnw",
+  "**/mvnw.cmd",
+  # Binary files
+  "**/*.jar",
+  # Repo docs (attribution examples in prose, not vendored code)
+  "AGENTS.md",
+  "CHANGELOG.md",
+  "CLAUDE.md",
+  "**/README.md",
+  # Warden infrastructure
+  ".warden/**",
+  "warden.toml",
+]
+
+[[skills.triggers]]
+type = "pull_request"
+actions = ["opened", "synchronize"]
+requestChanges = false
+failCheck = false
+
+[[skills.triggers]]
+type = "local"

From e4890419828e026a9274db932adfcc9f372f024b Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 22 May 2026 15:54:02 +0200
Subject: [PATCH 167/391] chore(build): Enable configuration cache parallel
 (#5461)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 gradle.properties | 1 +
 1 file changed, 1 insertion(+)

diff --git a/gradle.properties b/gradle.properties
index a8f42329732..2eb795118a0 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -4,6 +4,7 @@ org.gradle.caching=true
 org.gradle.parallel=true
 org.gradle.configureondemand=true
 org.gradle.configuration-cache=true
+org.gradle.configuration-cache.parallel=true
 
 org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 

From 44472dad40ff9fcb705cf476fea94023bbbf66a4 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 22 May 2026 15:54:12 +0200
Subject: [PATCH 168/391] ref(build): Move apply<MavenPublishPlugin>() outside
 afterEvaluate (#5464)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 build.gradle.kts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 6656e00e49a..8df6e48fe53 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -214,9 +214,9 @@ subprojects {
             }
         }
 
-        afterEvaluate {
-            apply<MavenPublishPlugin>()
+        apply<MavenPublishPlugin>()
 
+        afterEvaluate {
             configure<MavenPublishBaseExtension> {
                 assignAarTypes()
             }

From 9669c2d4e1fcf4aa0aa5b73df61d90026a3822b7 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Tue, 26 May 2026 14:59:55 +0200
Subject: [PATCH 169/391] feat(android): Parse memory and GC info from ANR
 thread dumps (#5428)

---
 CHANGELOG.md                                  |   1 +
 .../sentry/android/core/AnrV2Integration.java |  16 +-
 .../internal/threaddump/ArtContextParser.java | 149 ++++++++
 .../internal/threaddump/ThreadDumpParser.java |  10 +
 .../threaddump/ArtContextParserTest.kt        | 130 +++++++
 .../threaddump/ThreadDumpParserTest.kt        |  31 ++
 sentry/api/sentry.api                         |  55 +++
 .../java/io/sentry/protocol/ArtContext.java   | 331 ++++++++++++++++++
 .../java/io/sentry/protocol/Contexts.java     |  13 +
 .../protocol/ArtContextSerializationTest.kt   |  72 ++++
 .../java/io/sentry/protocol/ArtContextTest.kt |  54 +++
 .../CombinedContextsViewSerializationTest.kt  |   1 +
 .../protocol/ContextsSerializationTest.kt     |   1 +
 .../src/test/resources/json/art_context.json  |  13 +
 sentry/src/test/resources/json/contexts.json  |  14 +
 15 files changed, 888 insertions(+), 3 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ArtContextParser.java
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ArtContextParserTest.kt
 create mode 100644 sentry/src/main/java/io/sentry/protocol/ArtContext.java
 create mode 100644 sentry/src/test/java/io/sentry/protocol/ArtContextSerializationTest.kt
 create mode 100644 sentry/src/test/java/io/sentry/protocol/ArtContextTest.kt
 create mode 100644 sentry/src/test/resources/json/art_context.json

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e869e9aac8..acc07254df0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
   - Enable via `options.isAttachRawTombstone = true` or manifest: `<meta-data android:name="io.sentry.tombstone.attach-raw" android:value="true" />`
 - Add API to clear feature flags from scopes ([#5426](https://github.com/getsentry/sentry-java/pull/5426))
 - Add support to configure reporting historical ANRs via `AndroidManifest.xml` using the  `io.sentry.anr.report-historical` attribute ([#5387](https://github.com/getsentry/sentry-java/pull/5387))
+- Parse ART memory and garbage collector info from ANR tombstones into ART context ([#5428](https://github.com/getsentry/sentry-java/pull/5428))
 
 ### Dependencies
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2Integration.java b/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2Integration.java
index 8d88285a356..285c3b77ade 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2Integration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AnrV2Integration.java
@@ -22,6 +22,7 @@
 import io.sentry.hints.AbnormalExit;
 import io.sentry.hints.Backfillable;
 import io.sentry.hints.BlockingFlushHint;
+import io.sentry.protocol.ArtContext;
 import io.sentry.protocol.DebugImage;
 import io.sentry.protocol.DebugMeta;
 import io.sentry.protocol.Message;
@@ -173,6 +174,9 @@ public boolean shouldReportHistorical() {
           debugMeta.setImages(result.debugImages);
           event.setDebugMeta(debugMeta);
         }
+        if (result.artContext != null) {
+          event.getContexts().setArt(result.artContext);
+        }
       }
       event.setLevel(SentryLevel.FATAL);
       event.setTimestamp(DateUtils.getDateTime(anrTimestamp));
@@ -209,6 +213,7 @@ public boolean shouldReportHistorical() {
 
         final @NotNull List<SentryThread> threads = threadDumpParser.getThreads();
         final @NotNull List<DebugImage> debugImages = threadDumpParser.getDebugImages();
+        final @Nullable ArtContext artContext = threadDumpParser.getArtContext();
 
         if (threads.isEmpty()) {
           // if the list is empty this means the system failed to capture a proper thread dump of
@@ -217,7 +222,7 @@ public boolean shouldReportHistorical() {
           // fall back to not reporting them
           return new ParseResult(ParseResult.Type.NO_DUMP);
         }
-        return new ParseResult(ParseResult.Type.DUMP, dump, threads, debugImages);
+        return new ParseResult(ParseResult.Type.DUMP, dump, threads, debugImages, artContext);
       } catch (Throwable e) {
         options.getLogger().log(SentryLevel.WARNING, "Failed to parse ANR thread dump", e);
         return new ParseResult(ParseResult.Type.ERROR, dump);
@@ -286,15 +291,17 @@ enum Type {
     }
 
     final Type type;
-    final byte[] dump;
+    final @Nullable byte[] dump;
     final @Nullable List<SentryThread> threads;
     final @Nullable List<DebugImage> debugImages;
+    final @Nullable ArtContext artContext;
 
     ParseResult(final @NotNull Type type) {
       this.type = type;
       this.dump = null;
       this.threads = null;
       this.debugImages = null;
+      this.artContext = null;
     }
 
     ParseResult(final @NotNull Type type, final byte[] dump) {
@@ -302,17 +309,20 @@ enum Type {
       this.dump = dump;
       this.threads = null;
       this.debugImages = null;
+      this.artContext = null;
     }
 
     ParseResult(
         final @NotNull Type type,
         final byte[] dump,
         final @Nullable List<SentryThread> threads,
-        final @Nullable List<DebugImage> debugImages) {
+        final @Nullable List<DebugImage> debugImages,
+        final @Nullable ArtContext artContext) {
       this.type = type;
       this.dump = dump;
       this.threads = threads;
       this.debugImages = debugImages;
+      this.artContext = artContext;
     }
   }
 }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ArtContextParser.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ArtContextParser.java
new file mode 100644
index 00000000000..af5e2214aba
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ArtContextParser.java
@@ -0,0 +1,149 @@
+package io.sentry.android.core.internal.threaddump;
+
+import io.sentry.protocol.ArtContext;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Parses ART runtime memory and GC metrics from ANR thread dump lines.
+ *
+ * @see <a href="https://android.googlesource.com/platform/art/+/master/runtime/gc/heap.cc#1282">ART
+ *     Heap::DumpGcCountRateHistogram</a>
+ */
+final class ArtContextParser {
+
+  private static final long KB = 1024;
+  private static final long MB = 1024 * KB;
+  private static final long GB = 1024 * MB;
+
+  private static final String FREE_MEMORY_PREFIX = "Free memory ";
+  private static final String FREE_MEMORY_UNTIL_GC_PREFIX = "Free memory until GC ";
+  private static final String FREE_MEMORY_UNTIL_OOME_PREFIX = "Free memory until OOME ";
+  private static final String TOTAL_MEMORY_PREFIX = "Total memory ";
+  private static final String MAX_MEMORY_PREFIX = "Max memory ";
+  private static final String TOTAL_TIME_WAITING_FOR_GC_PREFIX =
+      "Total time waiting for GC to complete: ";
+  private static final String TOTAL_GC_COUNT_PREFIX = "Total GC count: ";
+  private static final String TOTAL_GC_TIME_PREFIX = "Total GC time: ";
+  private static final String TOTAL_BLOCKING_GC_COUNT_PREFIX = "Total blocking GC count: ";
+  private static final String TOTAL_BLOCKING_GC_TIME_PREFIX = "Total blocking GC time: ";
+  private static final String TOTAL_PRE_OOME_GC_COUNT_PREFIX = "Total pre-OOME GC count: ";
+
+  private @Nullable ArtContext artContext;
+
+  @Nullable
+  ArtContext getArtContext() {
+    return artContext;
+  }
+
+  void parseLine(final @NotNull String text) {
+    if (text.startsWith(FREE_MEMORY_UNTIL_OOME_PREFIX)) {
+      getOrCreateArtContext()
+          .setFreeMemoryUntilOome(
+              parsePrettySize(text.substring(FREE_MEMORY_UNTIL_OOME_PREFIX.length())));
+    } else if (text.startsWith(FREE_MEMORY_UNTIL_GC_PREFIX)) {
+      getOrCreateArtContext()
+          .setFreeMemoryUntilGc(
+              parsePrettySize(text.substring(FREE_MEMORY_UNTIL_GC_PREFIX.length())));
+    } else if (text.startsWith(FREE_MEMORY_PREFIX)) {
+      getOrCreateArtContext()
+          .setFreeMemory(parsePrettySize(text.substring(FREE_MEMORY_PREFIX.length())));
+    } else if (text.startsWith(TOTAL_MEMORY_PREFIX)) {
+      getOrCreateArtContext()
+          .setTotalMemory(parsePrettySize(text.substring(TOTAL_MEMORY_PREFIX.length())));
+    } else if (text.startsWith(MAX_MEMORY_PREFIX)) {
+      getOrCreateArtContext()
+          .setMaxMemory(parsePrettySize(text.substring(MAX_MEMORY_PREFIX.length())));
+    } else if (text.startsWith(TOTAL_TIME_WAITING_FOR_GC_PREFIX)) {
+      getOrCreateArtContext()
+          .setGcWaitingTime(parseTimeMs(text.substring(TOTAL_TIME_WAITING_FOR_GC_PREFIX.length())));
+    } else if (text.startsWith(TOTAL_GC_TIME_PREFIX)) {
+      getOrCreateArtContext()
+          .setGcTotalTime(parseTimeMs(text.substring(TOTAL_GC_TIME_PREFIX.length())));
+    } else if (text.startsWith(TOTAL_GC_COUNT_PREFIX)) {
+      getOrCreateArtContext()
+          .setGcTotalCount(parseLongOrNull(text.substring(TOTAL_GC_COUNT_PREFIX.length())));
+    } else if (text.startsWith(TOTAL_BLOCKING_GC_TIME_PREFIX)) {
+      getOrCreateArtContext()
+          .setGcBlockingTime(parseTimeMs(text.substring(TOTAL_BLOCKING_GC_TIME_PREFIX.length())));
+    } else if (text.startsWith(TOTAL_BLOCKING_GC_COUNT_PREFIX)) {
+      getOrCreateArtContext()
+          .setGcBlockingCount(
+              parseLongOrNull(text.substring(TOTAL_BLOCKING_GC_COUNT_PREFIX.length())));
+    } else if (text.startsWith(TOTAL_PRE_OOME_GC_COUNT_PREFIX)) {
+      getOrCreateArtContext()
+          .setGcPreOomeCount(
+              parseLongOrNull(text.substring(TOTAL_PRE_OOME_GC_COUNT_PREFIX.length())));
+    }
+  }
+
+  private @NotNull ArtContext getOrCreateArtContext() {
+    if (artContext == null) {
+      artContext = new ArtContext();
+    }
+    return artContext;
+  }
+
+  /**
+   * Matches Android's PrettySize output: number followed by unit with no space, e.g. "3107KB".
+   *
+   * <p>Counterpart to
+   * https://cs.android.com/android/platform/superproject/+/android-latest-release:art/libartbase/base/utils.cc;l=232-251;drc=d0d3deb269b1e14de2ec2707815e38bc95de570c
+   */
+  private @Nullable Long parsePrettySize(final @NotNull String sizeString) {
+    final String trimmed = sizeString.trim();
+    try {
+      if (trimmed.endsWith("GB")) {
+        return Long.parseLong(trimmed.substring(0, trimmed.length() - 2)) * GB;
+      } else if (trimmed.endsWith("MB")) {
+        return Long.parseLong(trimmed.substring(0, trimmed.length() - 2)) * MB;
+      } else if (trimmed.endsWith("KB")) {
+        return Long.parseLong(trimmed.substring(0, trimmed.length() - 2)) * KB;
+      } else if (trimmed.endsWith("B")) {
+        return Long.parseLong(trimmed.substring(0, trimmed.length() - 1));
+      }
+    } catch (NumberFormatException e) {
+      return null;
+    }
+    return null;
+  }
+
+  /**
+   * Parses ART's PrettyDuration output and converts to milliseconds. Handles "s", "ms", "us", "ns"
+   * suffixes and the bare "0" special case.
+   *
+   * @see <a
+   *     href="https://cs.android.com/android/platform/superproject/+/android-latest-release:art/libartbase/base/time_utils.cc;l=95-133;drc=16e1409f339b1318fe1cdce8462f089b3b0475e8">ART
+   *     PrettyDuration / FormatDuration</a>
+   */
+  private static @Nullable Double parseTimeMs(final @NotNull String timeString) {
+    final String trimmed = timeString.trim();
+    try {
+      if (trimmed.equals("0")) {
+        return 0.0;
+      }
+      // Double.parseDouble is locale-independent (always uses '.' as decimal separator),
+      // which matches the ART runtime output format.
+      if (trimmed.endsWith("ms")) {
+        return Double.parseDouble(trimmed.substring(0, trimmed.length() - 2));
+      } else if (trimmed.endsWith("ns")) {
+        return Double.parseDouble(trimmed.substring(0, trimmed.length() - 2)) / 1_000_000.0;
+      } else if (trimmed.endsWith("us")) {
+        return Double.parseDouble(trimmed.substring(0, trimmed.length() - 2)) / 1_000.0;
+      } else if (trimmed.endsWith("s")) {
+        return Double.parseDouble(trimmed.substring(0, trimmed.length() - 1)) * 1_000.0;
+      }
+    } catch (NumberFormatException e) {
+      return null;
+    }
+    return null;
+  }
+
+  private static @Nullable Long parseLongOrNull(final @NotNull String value) {
+    try {
+      return Long.parseLong(value.trim());
+    } catch (NumberFormatException e) {
+      return null;
+    }
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ThreadDumpParser.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ThreadDumpParser.java
index 5f70e39f8b8..f5ce8a745ce 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ThreadDumpParser.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ThreadDumpParser.java
@@ -23,6 +23,7 @@
 import io.sentry.SentryOptions;
 import io.sentry.SentryStackTraceFactory;
 import io.sentry.android.core.internal.util.NativeEventUtils;
+import io.sentry.protocol.ArtContext;
 import io.sentry.protocol.DebugImage;
 import io.sentry.protocol.SentryStackFrame;
 import io.sentry.protocol.SentryStackTrace;
@@ -109,6 +110,8 @@ public class ThreadDumpParser {
 
   private final @NotNull List<SentryThread> threads;
 
+  private final @NotNull ArtContextParser artContextParser = new ArtContextParser();
+
   public ThreadDumpParser(final @NotNull SentryOptions options, final boolean isBackground) {
     this.options = options;
     this.isBackground = isBackground;
@@ -127,6 +130,11 @@ public List<SentryThread> getThreads() {
     return threads;
   }
 
+  @Nullable
+  public ArtContext getArtContext() {
+    return artContextParser.getArtContext();
+  }
+
   public void parse(final @NotNull Lines lines) {
 
     final Matcher beginManagedThreadRe = BEGIN_MANAGED_THREAD_RE.matcher("");
@@ -148,6 +156,8 @@ public void parse(final @NotNull Lines lines) {
         if (thread != null) {
           threads.add(thread);
         }
+      } else {
+        artContextParser.parseLine(text);
       }
     }
   }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ArtContextParserTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ArtContextParserTest.kt
new file mode 100644
index 00000000000..b468127660c
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ArtContextParserTest.kt
@@ -0,0 +1,130 @@
+package io.sentry.android.core.internal.threaddump
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+
+class ArtContextParserTest {
+
+  @Test
+  fun `parses pretty size bytes`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Free memory 0B")
+    assertEquals(0L, parser.artContext!!.freeMemory)
+
+    val parser2 = ArtContextParser()
+    parser2.parseLine("Free memory 512B")
+    assertEquals(512L, parser2.artContext!!.freeMemory)
+  }
+
+  @Test
+  fun `parses pretty size kilobytes`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Free memory 3107KB")
+    assertEquals(3107L * 1024, parser.artContext!!.freeMemory)
+  }
+
+  @Test
+  fun `parses pretty size megabytes`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Free memory until OOME 187MB")
+    assertEquals(187L * 1024 * 1024, parser.artContext!!.freeMemoryUntilOome)
+  }
+
+  @Test
+  fun `parses pretty size gigabytes`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Max memory 2GB")
+    assertEquals(2L * 1024 * 1024 * 1024, parser.artContext!!.maxMemory)
+  }
+
+  @Test
+  fun `sets null for invalid pretty size`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Free memory 100TB")
+    assertNull(parser.artContext!!.freeMemory)
+  }
+
+  @Test
+  fun `parses time in milliseconds`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Total GC time: 11.807ms")
+    assertEquals(11.807, parser.artContext!!.gcTotalTime)
+  }
+
+  @Test
+  fun `parses time in seconds`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Total GC time: 2.5s")
+    assertEquals(2500.0, parser.artContext!!.gcTotalTime)
+  }
+
+  @Test
+  fun `parses time in microseconds`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Total GC time: 500us")
+    assertEquals(0.5, parser.artContext!!.gcTotalTime)
+  }
+
+  @Test
+  fun `parses time in nanoseconds`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Total GC time: 1000000ns")
+    assertEquals(1.0, parser.artContext!!.gcTotalTime)
+  }
+
+  @Test
+  fun `parses zero duration`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Total GC time: 0")
+    assertEquals(0.0, parser.artContext!!.gcTotalTime)
+  }
+
+  @Test
+  fun `parses all memory fields`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Free memory 3107KB")
+    parser.parseLine("Free memory until GC 3107KB")
+    parser.parseLine("Free memory until OOME 187MB")
+    parser.parseLine("Total memory 7592KB")
+    parser.parseLine("Max memory 192MB")
+
+    val info = parser.artContext
+    assertNotNull(info)
+    assertEquals(3107L * 1024, info.freeMemory)
+    assertEquals(3107L * 1024, info.freeMemoryUntilGc)
+    assertEquals(187L * 1024 * 1024, info.freeMemoryUntilOome)
+    assertEquals(7592L * 1024, info.totalMemory)
+    assertEquals(192L * 1024 * 1024, info.maxMemory)
+  }
+
+  @Test
+  fun `parses all gc fields`() {
+    val parser = ArtContextParser()
+    parser.parseLine("Total time waiting for GC to complete: 8.054ms")
+    parser.parseLine("Total GC count: 1")
+    parser.parseLine("Total GC time: 11.807ms")
+    parser.parseLine("Total blocking GC count: 1")
+    parser.parseLine("Total blocking GC time: 11.873ms")
+    parser.parseLine("Total pre-OOME GC count: 0")
+
+    val info = parser.artContext
+    assertNotNull(info)
+    assertEquals(8.054, info.gcWaitingTime)
+    assertEquals(1L, info.gcTotalCount)
+    assertEquals(11.807, info.gcTotalTime)
+    assertEquals(1L, info.gcBlockingCount)
+    assertEquals(11.873, info.gcBlockingTime)
+    assertEquals(0L, info.gcPreOomeCount)
+  }
+
+  @Test
+  fun `ignores unrelated lines`() {
+    val parser = ArtContextParser()
+    parser.parseLine("some random line")
+    parser.parseLine("DALVIK THREADS (29):")
+    parser.parseLine("")
+    assertNull(parser.artContext)
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt
index 604e2e84189..b7db35b63ce 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt
@@ -160,6 +160,28 @@ class ThreadDumpParserTest {
     assertEquals("ba489d4985c0cf173209da67405662f9", image.codeId)
   }
 
+  @Test
+  fun `parses memory info from thread dump`() {
+    val lines = Lines.readLines(File("src/test/resources/thread_dump.txt"))
+    val parser =
+      ThreadDumpParser(SentryOptions().apply { addInAppInclude("io.sentry.samples") }, false)
+    parser.parse(lines)
+
+    val artContext = parser.artContext
+    assertNotNull(artContext)
+    assertEquals(3107L * 1024, artContext.freeMemory)
+    assertEquals(3107L * 1024, artContext.freeMemoryUntilGc)
+    assertEquals(187L * 1024 * 1024, artContext.freeMemoryUntilOome)
+    assertEquals(7592L * 1024, artContext.totalMemory)
+    assertEquals(192L * 1024 * 1024, artContext.maxMemory)
+    assertEquals(1L, artContext.gcTotalCount)
+    assertEquals(11.807, artContext.gcTotalTime)
+    assertEquals(1L, artContext.gcBlockingCount)
+    assertEquals(11.873, artContext.gcBlockingTime)
+    assertEquals(0L, artContext.gcPreOomeCount)
+    assertEquals(8.054, artContext.gcWaitingTime)
+  }
+
   @Test
   fun `thread dump garbage`() {
     val lines = Lines.readLines(File("src/test/resources/thread_dump_bad_data.txt"))
@@ -168,4 +190,13 @@ class ThreadDumpParserTest {
     parser.parse(lines)
     assertTrue(parser.threads.isEmpty())
   }
+
+  @Test
+  fun `garbage thread dump has no memory info`() {
+    val lines = Lines.readLines(File("src/test/resources/thread_dump_bad_data.txt"))
+    val parser =
+      ThreadDumpParser(SentryOptions().apply { addInAppInclude("io.sentry.samples") }, false)
+    parser.parse(lines)
+    assertNull(parser.artContext)
+  }
 }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 6b8377de3a3..d2fd5f75dbc 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -5657,6 +5657,59 @@ public final class io/sentry/protocol/App$JsonKeys {
 	public fun <init> ()V
 }
 
+public final class io/sentry/protocol/ArtContext : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
+	public static final field TYPE Ljava/lang/String;
+	public fun <init> ()V
+	public fun equals (Ljava/lang/Object;)Z
+	public fun getFreeMemory ()Ljava/lang/Long;
+	public fun getFreeMemoryUntilGc ()Ljava/lang/Long;
+	public fun getFreeMemoryUntilOome ()Ljava/lang/Long;
+	public fun getGcBlockingCount ()Ljava/lang/Long;
+	public fun getGcBlockingTime ()Ljava/lang/Double;
+	public fun getGcPreOomeCount ()Ljava/lang/Long;
+	public fun getGcTotalCount ()Ljava/lang/Long;
+	public fun getGcTotalTime ()Ljava/lang/Double;
+	public fun getGcWaitingTime ()Ljava/lang/Double;
+	public fun getMaxMemory ()Ljava/lang/Long;
+	public fun getTotalMemory ()Ljava/lang/Long;
+	public fun getUnknown ()Ljava/util/Map;
+	public fun hashCode ()I
+	public fun serialize (Lio/sentry/ObjectWriter;Lio/sentry/ILogger;)V
+	public fun setFreeMemory (Ljava/lang/Long;)V
+	public fun setFreeMemoryUntilGc (Ljava/lang/Long;)V
+	public fun setFreeMemoryUntilOome (Ljava/lang/Long;)V
+	public fun setGcBlockingCount (Ljava/lang/Long;)V
+	public fun setGcBlockingTime (Ljava/lang/Double;)V
+	public fun setGcPreOomeCount (Ljava/lang/Long;)V
+	public fun setGcTotalCount (Ljava/lang/Long;)V
+	public fun setGcTotalTime (Ljava/lang/Double;)V
+	public fun setGcWaitingTime (Ljava/lang/Double;)V
+	public fun setMaxMemory (Ljava/lang/Long;)V
+	public fun setTotalMemory (Ljava/lang/Long;)V
+	public fun setUnknown (Ljava/util/Map;)V
+}
+
+public final class io/sentry/protocol/ArtContext$Deserializer : io/sentry/JsonDeserializer {
+	public fun <init> ()V
+	public fun deserialize (Lio/sentry/ObjectReader;Lio/sentry/ILogger;)Lio/sentry/protocol/ArtContext;
+	public synthetic fun deserialize (Lio/sentry/ObjectReader;Lio/sentry/ILogger;)Ljava/lang/Object;
+}
+
+public final class io/sentry/protocol/ArtContext$JsonKeys {
+	public static final field FREE_MEMORY Ljava/lang/String;
+	public static final field FREE_MEMORY_UNTIL_GC Ljava/lang/String;
+	public static final field FREE_MEMORY_UNTIL_OOME Ljava/lang/String;
+	public static final field GC_BLOCKING_COUNT Ljava/lang/String;
+	public static final field GC_BLOCKING_TIME Ljava/lang/String;
+	public static final field GC_PRE_OOME_COUNT Ljava/lang/String;
+	public static final field GC_TOTAL_COUNT Ljava/lang/String;
+	public static final field GC_TOTAL_TIME Ljava/lang/String;
+	public static final field GC_WAITING_TIME Ljava/lang/String;
+	public static final field MAX_MEMORY Ljava/lang/String;
+	public static final field TOTAL_MEMORY Ljava/lang/String;
+	public fun <init> ()V
+}
+
 public final class io/sentry/protocol/Browser : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
 	public static final field TYPE Ljava/lang/String;
 	public fun <init> ()V
@@ -5693,6 +5746,7 @@ public class io/sentry/protocol/Contexts : io/sentry/JsonSerializable {
 	public fun equals (Ljava/lang/Object;)Z
 	public fun get (Ljava/lang/Object;)Ljava/lang/Object;
 	public fun getApp ()Lio/sentry/protocol/App;
+	public fun getArt ()Lio/sentry/protocol/ArtContext;
 	public fun getBrowser ()Lio/sentry/protocol/Browser;
 	public fun getDevice ()Lio/sentry/protocol/Device;
 	public fun getFeatureFlags ()Lio/sentry/protocol/FeatureFlags;
@@ -5715,6 +5769,7 @@ public class io/sentry/protocol/Contexts : io/sentry/JsonSerializable {
 	public fun serialize (Lio/sentry/ObjectWriter;Lio/sentry/ILogger;)V
 	public fun set (Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;
 	public fun setApp (Lio/sentry/protocol/App;)V
+	public fun setArt (Lio/sentry/protocol/ArtContext;)V
 	public fun setBrowser (Lio/sentry/protocol/Browser;)V
 	public fun setDevice (Lio/sentry/protocol/Device;)V
 	public fun setFeatureFlags (Lio/sentry/protocol/FeatureFlags;)V
diff --git a/sentry/src/main/java/io/sentry/protocol/ArtContext.java b/sentry/src/main/java/io/sentry/protocol/ArtContext.java
new file mode 100644
index 00000000000..c840f48af91
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/protocol/ArtContext.java
@@ -0,0 +1,331 @@
+package io.sentry.protocol;
+
+import io.sentry.ILogger;
+import io.sentry.JsonDeserializer;
+import io.sentry.JsonSerializable;
+import io.sentry.JsonUnknown;
+import io.sentry.ObjectReader;
+import io.sentry.ObjectWriter;
+import io.sentry.util.CollectionUtils;
+import io.sentry.util.Objects;
+import io.sentry.vendor.gson.stream.JsonToken;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Context containing ART (Android Runtime) specific information. This is only relevant for Android
+ * and may be null on other platforms.
+ */
+public final class ArtContext implements JsonUnknown, JsonSerializable {
+  public static final String TYPE = "art";
+
+  private @Nullable Long gcTotalCount;
+  private @Nullable Double gcTotalTime;
+  private @Nullable Long gcBlockingCount;
+  private @Nullable Double gcBlockingTime;
+  private @Nullable Long gcPreOomeCount;
+  private @Nullable Double gcWaitingTime;
+  private @Nullable Long freeMemory;
+  private @Nullable Long freeMemoryUntilGc;
+  private @Nullable Long freeMemoryUntilOome;
+  private @Nullable Long totalMemory;
+  private @Nullable Long maxMemory;
+
+  @SuppressWarnings("unused")
+  private @Nullable Map<String, @NotNull Object> unknown;
+
+  public ArtContext() {}
+
+  ArtContext(final @NotNull ArtContext other) {
+    this.gcTotalCount = other.gcTotalCount;
+    this.gcTotalTime = other.gcTotalTime;
+    this.gcBlockingCount = other.gcBlockingCount;
+    this.gcBlockingTime = other.gcBlockingTime;
+    this.gcPreOomeCount = other.gcPreOomeCount;
+    this.gcWaitingTime = other.gcWaitingTime;
+    this.freeMemory = other.freeMemory;
+    this.freeMemoryUntilGc = other.freeMemoryUntilGc;
+    this.freeMemoryUntilOome = other.freeMemoryUntilOome;
+    this.totalMemory = other.totalMemory;
+    this.maxMemory = other.maxMemory;
+    this.unknown = CollectionUtils.newConcurrentHashMap(other.unknown);
+  }
+
+  /** Total number of GC collections since process start. */
+  public @Nullable Long getGcTotalCount() {
+    return gcTotalCount;
+  }
+
+  /** Total number of GC collections since process start. */
+  public void setGcTotalCount(final @Nullable Long gcTotalCount) {
+    this.gcTotalCount = gcTotalCount;
+  }
+
+  /** Total time spent in GC since process start, in milliseconds. */
+  public @Nullable Double getGcTotalTime() {
+    return gcTotalTime;
+  }
+
+  /** Total time spent in GC since process start, in milliseconds. */
+  public void setGcTotalTime(final @Nullable Double gcTotalTime) {
+    this.gcTotalTime = gcTotalTime;
+  }
+
+  /** Total number of blocking (stop-the-world) GC collections since process start. */
+  public @Nullable Long getGcBlockingCount() {
+    return gcBlockingCount;
+  }
+
+  /** Total number of blocking (stop-the-world) GC collections since process start. */
+  public void setGcBlockingCount(final @Nullable Long gcBlockingCount) {
+    this.gcBlockingCount = gcBlockingCount;
+  }
+
+  /** Total time spent in blocking (stop-the-world) GC since process start, in milliseconds. */
+  public @Nullable Double getGcBlockingTime() {
+    return gcBlockingTime;
+  }
+
+  /** Total time spent in blocking (stop-the-world) GC since process start, in milliseconds. */
+  public void setGcBlockingTime(final @Nullable Double gcBlockingTime) {
+    this.gcBlockingTime = gcBlockingTime;
+  }
+
+  /** Total number of GC collections triggered to prevent an OutOfMemoryError. */
+  public @Nullable Long getGcPreOomeCount() {
+    return gcPreOomeCount;
+  }
+
+  /** Total number of GC collections triggered to prevent an OutOfMemoryError. */
+  public void setGcPreOomeCount(final @Nullable Long gcPreOomeCount) {
+    this.gcPreOomeCount = gcPreOomeCount;
+  }
+
+  /** Total time threads spent waiting for GC to complete, in milliseconds. */
+  public @Nullable Double getGcWaitingTime() {
+    return gcWaitingTime;
+  }
+
+  /** Total time threads spent waiting for GC to complete, in milliseconds. */
+  public void setGcWaitingTime(final @Nullable Double gcWaitingTime) {
+    this.gcWaitingTime = gcWaitingTime;
+  }
+
+  /** Free memory available in the managed heap, in bytes. */
+  public @Nullable Long getFreeMemory() {
+    return freeMemory;
+  }
+
+  /** Free memory available in the managed heap, in bytes. */
+  public void setFreeMemory(final @Nullable Long freeMemory) {
+    this.freeMemory = freeMemory;
+  }
+
+  /** Free memory available until the next GC is triggered, in bytes. */
+  public @Nullable Long getFreeMemoryUntilGc() {
+    return freeMemoryUntilGc;
+  }
+
+  /** Free memory available until the next GC is triggered, in bytes. */
+  public void setFreeMemoryUntilGc(final @Nullable Long freeMemoryUntilGc) {
+    this.freeMemoryUntilGc = freeMemoryUntilGc;
+  }
+
+  /** Free memory available until an OutOfMemoryError is thrown, in bytes. */
+  public @Nullable Long getFreeMemoryUntilOome() {
+    return freeMemoryUntilOome;
+  }
+
+  /** Free memory available until an OutOfMemoryError is thrown, in bytes. */
+  public void setFreeMemoryUntilOome(final @Nullable Long freeMemoryUntilOome) {
+    this.freeMemoryUntilOome = freeMemoryUntilOome;
+  }
+
+  /** Total memory currently allocated for the managed heap, in bytes. */
+  public @Nullable Long getTotalMemory() {
+    return totalMemory;
+  }
+
+  /** Total memory currently allocated for the managed heap, in bytes. */
+  public void setTotalMemory(final @Nullable Long totalMemory) {
+    this.totalMemory = totalMemory;
+  }
+
+  /** Maximum memory the managed heap is allowed to grow to, in bytes. */
+  public @Nullable Long getMaxMemory() {
+    return maxMemory;
+  }
+
+  /** Maximum memory the managed heap is allowed to grow to, in bytes. */
+  public void setMaxMemory(final @Nullable Long maxMemory) {
+    this.maxMemory = maxMemory;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+    ArtContext that = (ArtContext) o;
+    return Objects.equals(gcTotalCount, that.gcTotalCount)
+        && Objects.equals(gcTotalTime, that.gcTotalTime)
+        && Objects.equals(gcBlockingCount, that.gcBlockingCount)
+        && Objects.equals(gcBlockingTime, that.gcBlockingTime)
+        && Objects.equals(gcPreOomeCount, that.gcPreOomeCount)
+        && Objects.equals(gcWaitingTime, that.gcWaitingTime)
+        && Objects.equals(freeMemory, that.freeMemory)
+        && Objects.equals(freeMemoryUntilGc, that.freeMemoryUntilGc)
+        && Objects.equals(freeMemoryUntilOome, that.freeMemoryUntilOome)
+        && Objects.equals(totalMemory, that.totalMemory)
+        && Objects.equals(maxMemory, that.maxMemory);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(
+        gcTotalCount,
+        gcTotalTime,
+        gcBlockingCount,
+        gcBlockingTime,
+        gcPreOomeCount,
+        gcWaitingTime,
+        freeMemory,
+        freeMemoryUntilGc,
+        freeMemoryUntilOome,
+        totalMemory,
+        maxMemory);
+  }
+
+  // region JsonSerializable
+
+  public static final class JsonKeys {
+    public static final String GC_TOTAL_COUNT = "gc.total_count";
+    public static final String GC_TOTAL_TIME = "gc.total_time";
+    public static final String GC_BLOCKING_COUNT = "gc.blocking_count";
+    public static final String GC_BLOCKING_TIME = "gc.blocking_time";
+    public static final String GC_PRE_OOME_COUNT = "gc.pre_oome_count";
+    public static final String GC_WAITING_TIME = "gc.waiting_time";
+    public static final String FREE_MEMORY = "memory.free";
+    public static final String FREE_MEMORY_UNTIL_GC = "memory.free_until_gc";
+    public static final String FREE_MEMORY_UNTIL_OOME = "memory.free_until_oome";
+    public static final String TOTAL_MEMORY = "memory.total";
+    public static final String MAX_MEMORY = "memory.max";
+  }
+
+  @Override
+  public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger logger)
+      throws IOException {
+    writer.beginObject();
+    if (gcTotalCount != null) {
+      writer.name(JsonKeys.GC_TOTAL_COUNT).value(gcTotalCount);
+    }
+    if (gcTotalTime != null) {
+      writer.name(JsonKeys.GC_TOTAL_TIME).value(gcTotalTime);
+    }
+    if (gcBlockingCount != null) {
+      writer.name(JsonKeys.GC_BLOCKING_COUNT).value(gcBlockingCount);
+    }
+    if (gcBlockingTime != null) {
+      writer.name(JsonKeys.GC_BLOCKING_TIME).value(gcBlockingTime);
+    }
+    if (gcPreOomeCount != null) {
+      writer.name(JsonKeys.GC_PRE_OOME_COUNT).value(gcPreOomeCount);
+    }
+    if (gcWaitingTime != null) {
+      writer.name(JsonKeys.GC_WAITING_TIME).value(gcWaitingTime);
+    }
+    if (freeMemory != null) {
+      writer.name(JsonKeys.FREE_MEMORY).value(freeMemory);
+    }
+    if (freeMemoryUntilGc != null) {
+      writer.name(JsonKeys.FREE_MEMORY_UNTIL_GC).value(freeMemoryUntilGc);
+    }
+    if (freeMemoryUntilOome != null) {
+      writer.name(JsonKeys.FREE_MEMORY_UNTIL_OOME).value(freeMemoryUntilOome);
+    }
+    if (totalMemory != null) {
+      writer.name(JsonKeys.TOTAL_MEMORY).value(totalMemory);
+    }
+    if (maxMemory != null) {
+      writer.name(JsonKeys.MAX_MEMORY).value(maxMemory);
+    }
+    if (unknown != null) {
+      for (String key : unknown.keySet()) {
+        Object value = unknown.get(key);
+        writer.name(key);
+        writer.value(logger, value);
+      }
+    }
+    writer.endObject();
+  }
+
+  @Nullable
+  @Override
+  public Map<String, Object> getUnknown() {
+    return unknown;
+  }
+
+  @Override
+  public void setUnknown(@Nullable Map<String, Object> unknown) {
+    this.unknown = unknown;
+  }
+
+  public static final class Deserializer implements JsonDeserializer<ArtContext> {
+    @Override
+    public @NotNull ArtContext deserialize(@NotNull ObjectReader reader, @NotNull ILogger logger)
+        throws Exception {
+      reader.beginObject();
+      ArtContext artContext = new ArtContext();
+      Map<String, Object> unknown = null;
+      while (reader.peek() == JsonToken.NAME) {
+        final String nextName = reader.nextName();
+        switch (nextName) {
+          case JsonKeys.GC_TOTAL_COUNT:
+            artContext.gcTotalCount = reader.nextLongOrNull();
+            break;
+          case JsonKeys.GC_TOTAL_TIME:
+            artContext.gcTotalTime = reader.nextDoubleOrNull();
+            break;
+          case JsonKeys.GC_BLOCKING_COUNT:
+            artContext.gcBlockingCount = reader.nextLongOrNull();
+            break;
+          case JsonKeys.GC_BLOCKING_TIME:
+            artContext.gcBlockingTime = reader.nextDoubleOrNull();
+            break;
+          case JsonKeys.GC_PRE_OOME_COUNT:
+            artContext.gcPreOomeCount = reader.nextLongOrNull();
+            break;
+          case JsonKeys.GC_WAITING_TIME:
+            artContext.gcWaitingTime = reader.nextDoubleOrNull();
+            break;
+          case JsonKeys.FREE_MEMORY:
+            artContext.freeMemory = reader.nextLongOrNull();
+            break;
+          case JsonKeys.FREE_MEMORY_UNTIL_GC:
+            artContext.freeMemoryUntilGc = reader.nextLongOrNull();
+            break;
+          case JsonKeys.FREE_MEMORY_UNTIL_OOME:
+            artContext.freeMemoryUntilOome = reader.nextLongOrNull();
+            break;
+          case JsonKeys.TOTAL_MEMORY:
+            artContext.totalMemory = reader.nextLongOrNull();
+            break;
+          case JsonKeys.MAX_MEMORY:
+            artContext.maxMemory = reader.nextLongOrNull();
+            break;
+          default:
+            if (unknown == null) {
+              unknown = new ConcurrentHashMap<>();
+            }
+            reader.nextUnknown(logger, unknown, nextName);
+            break;
+        }
+      }
+      artContext.setUnknown(unknown);
+      reader.endObject();
+      return artContext;
+    }
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/protocol/Contexts.java b/sentry/src/main/java/io/sentry/protocol/Contexts.java
index 553f4ddbd30..fd1e9b83eb6 100644
--- a/sentry/src/main/java/io/sentry/protocol/Contexts.java
+++ b/sentry/src/main/java/io/sentry/protocol/Contexts.java
@@ -64,6 +64,8 @@ public Contexts(final @NotNull Contexts contexts) {
           this.setResponse(new Response((Response) value));
         } else if (Spring.TYPE.equals(entry.getKey()) && value instanceof Spring) {
           this.setSpring(new Spring((Spring) value));
+        } else if (ArtContext.TYPE.equals(entry.getKey()) && value instanceof ArtContext) {
+          this.setArt(new ArtContext((ArtContext) value));
         } else {
           this.put(entry.getKey(), value);
         }
@@ -181,6 +183,14 @@ public void setSpring(final @NotNull Spring spring) {
     this.put(Spring.TYPE, spring);
   }
 
+  public @Nullable ArtContext getArt() {
+    return toContextType(ArtContext.TYPE, ArtContext.class);
+  }
+
+  public void setArt(final @NotNull ArtContext art) {
+    this.put(ArtContext.TYPE, art);
+  }
+
   public @Nullable FeatureFlags getFeatureFlags() {
     return toContextType(FeatureFlags.TYPE, FeatureFlags.class);
   }
@@ -347,6 +357,9 @@ public static final class Deserializer implements JsonDeserializer<Contexts> {
           case Spring.TYPE:
             contexts.setSpring(new Spring.Deserializer().deserialize(reader, logger));
             break;
+          case ArtContext.TYPE:
+            contexts.setArt(new ArtContext.Deserializer().deserialize(reader, logger));
+            break;
           case FeatureFlags.TYPE:
             contexts.setFeatureFlags(new FeatureFlags.Deserializer().deserialize(reader, logger));
             break;
diff --git a/sentry/src/test/java/io/sentry/protocol/ArtContextSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/ArtContextSerializationTest.kt
new file mode 100644
index 00000000000..9825194cd13
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/protocol/ArtContextSerializationTest.kt
@@ -0,0 +1,72 @@
+package io.sentry.protocol
+
+import io.sentry.ILogger
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import org.junit.Test
+import org.mockito.kotlin.mock
+
+class ArtContextSerializationTest {
+  class Fixture {
+    val logger = mock<ILogger>()
+
+    fun getSut() =
+      ArtContext().apply {
+        gcTotalCount = 1L
+        gcTotalTime = 11.807
+        gcBlockingCount = 1L
+        gcBlockingTime = 11.873
+        gcPreOomeCount = 0L
+        gcWaitingTime = 8.054
+        freeMemory = 3181568L
+        freeMemoryUntilGc = 3181568L
+        freeMemoryUntilOome = 196083712L
+        totalMemory = 7774208L
+        maxMemory = 201326592L
+      }
+  }
+
+  private val fixture = Fixture()
+
+  @Test
+  fun serialize() {
+    val expected = SerializationUtils.sanitizedFile("json/art_context.json")
+    val actual = SerializationUtils.serializeToString(fixture.getSut(), fixture.logger)
+
+    assertEquals(expected, actual)
+  }
+
+  @Test
+  fun deserialize() {
+    val expectedJson = SerializationUtils.sanitizedFile("json/art_context.json")
+    val actual =
+      SerializationUtils.deserializeJson<ArtContext>(
+        expectedJson,
+        ArtContext.Deserializer(),
+        fixture.logger,
+      )
+    val actualJson = SerializationUtils.serializeToString(actual, fixture.logger)
+
+    assertEquals(expectedJson, actualJson)
+  }
+
+  @Test
+  fun `deserialize preserves unknown fields`() {
+    val jsonWithUnknown =
+      SerializationUtils.sanitizedFile("json/art_context.json")
+        .removeSuffix("}")
+        .plus(",\"new_field\":\"test_value\"}")
+    val actual =
+      SerializationUtils.deserializeJson<ArtContext>(
+        jsonWithUnknown,
+        ArtContext.Deserializer(),
+        fixture.logger,
+      )
+
+    assertNotNull(actual.unknown)
+    assertEquals("test_value", actual.unknown!!["new_field"])
+
+    val actualJson = SerializationUtils.serializeToString(actual, fixture.logger)
+    assertEquals(jsonWithUnknown, actualJson)
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/protocol/ArtContextTest.kt b/sentry/src/test/java/io/sentry/protocol/ArtContextTest.kt
new file mode 100644
index 00000000000..275123e494e
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/protocol/ArtContextTest.kt
@@ -0,0 +1,54 @@
+package io.sentry.protocol
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNotSame
+
+class ArtContextTest {
+  @Test
+  fun `copying art context wont have the same references`() {
+    val artContext = ArtContext()
+    val unknown = mapOf(Pair("unknown", "unknown"))
+    artContext.setUnknown(unknown)
+
+    val clone = ArtContext(artContext)
+
+    assertNotNull(clone)
+    assertNotSame(artContext, clone)
+    assertNotSame(artContext.unknown, clone.unknown)
+  }
+
+  @Test
+  fun `copying art context will have the same values`() {
+    val artContext = ArtContext()
+    artContext.gcTotalCount = 10L
+    artContext.gcTotalTime = 11.807
+    artContext.gcBlockingCount = 2L
+    artContext.gcBlockingTime = 5.123
+    artContext.gcPreOomeCount = 1L
+    artContext.gcWaitingTime = 8.054
+    artContext.freeMemory = 3181568L
+    artContext.freeMemoryUntilGc = 3181568L
+    artContext.freeMemoryUntilOome = 196083712L
+    artContext.totalMemory = 7774208L
+    artContext.maxMemory = 201326592L
+    val unknown = mapOf(Pair("unknown", "unknown"))
+    artContext.setUnknown(unknown)
+
+    val clone = ArtContext(artContext)
+
+    assertEquals(10L, clone.gcTotalCount)
+    assertEquals(11.807, clone.gcTotalTime)
+    assertEquals(2L, clone.gcBlockingCount)
+    assertEquals(5.123, clone.gcBlockingTime)
+    assertEquals(1L, clone.gcPreOomeCount)
+    assertEquals(8.054, clone.gcWaitingTime)
+    assertEquals(3181568L, clone.freeMemory)
+    assertEquals(3181568L, clone.freeMemoryUntilGc)
+    assertEquals(196083712L, clone.freeMemoryUntilOome)
+    assertEquals(7774208L, clone.totalMemory)
+    assertEquals(201326592L, clone.maxMemory)
+    assertNotNull(clone.unknown) { assertEquals("unknown", it["unknown"]) }
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/protocol/CombinedContextsViewSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/CombinedContextsViewSerializationTest.kt
index d7fd3cf9f7f..33db7a2e29d 100644
--- a/sentry/src/test/java/io/sentry/protocol/CombinedContextsViewSerializationTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/CombinedContextsViewSerializationTest.kt
@@ -22,6 +22,7 @@ class CombinedContextsViewSerializationTest {
       val combined = CombinedContextsView(global, isolation, current, ScopeType.ISOLATION)
 
       current.setApp(AppSerializationTest.Fixture().getSut())
+      current.setArt(ArtContextSerializationTest.Fixture().getSut())
       current.setBrowser(BrowserSerializationTest.Fixture().getSut())
       current.setFeedback(FeedbackTest.Fixture().getSut())
       current.setTrace(SpanContextSerializationTest.Fixture().getSut())
diff --git a/sentry/src/test/java/io/sentry/protocol/ContextsSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/ContextsSerializationTest.kt
index 1a5e252a76d..8e17de9c686 100644
--- a/sentry/src/test/java/io/sentry/protocol/ContextsSerializationTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/ContextsSerializationTest.kt
@@ -25,6 +25,7 @@ class ContextsSerializationTest {
         setResponse(ResponseSerializationTest.Fixture().getSut())
         setTrace(SpanContextSerializationTest.Fixture().getSut())
         setSpring(SpringSerializationTest.Fixture().getSut())
+        setArt(ArtContextSerializationTest.Fixture().getSut())
         setFeatureFlags(FeatureFlagsSerializationTest.Fixture().getSut())
       }
   }
diff --git a/sentry/src/test/resources/json/art_context.json b/sentry/src/test/resources/json/art_context.json
new file mode 100644
index 00000000000..f15596574f5
--- /dev/null
+++ b/sentry/src/test/resources/json/art_context.json
@@ -0,0 +1,13 @@
+{
+  "gc.total_count": 1,
+  "gc.total_time": 11.807,
+  "gc.blocking_count": 1,
+  "gc.blocking_time": 11.873,
+  "gc.pre_oome_count": 0,
+  "gc.waiting_time": 8.054,
+  "memory.free": 3181568,
+  "memory.free_until_gc": 3181568,
+  "memory.free_until_oome": 196083712,
+  "memory.total": 7774208,
+  "memory.max": 201326592
+}
diff --git a/sentry/src/test/resources/json/contexts.json b/sentry/src/test/resources/json/contexts.json
index 7f4c0c16bc2..0670c8a6e84 100644
--- a/sentry/src/test/resources/json/contexts.json
+++ b/sentry/src/test/resources/json/contexts.json
@@ -17,6 +17,20 @@
     "view_names": ["MainActivity", "SidebarActivity"],
     "start_type": "cold"
   },
+  "art":
+  {
+    "gc.total_count": 1,
+    "gc.total_time": 11.807,
+    "gc.blocking_count": 1,
+    "gc.blocking_time": 11.873,
+    "gc.pre_oome_count": 0,
+    "gc.waiting_time": 8.054,
+    "memory.free": 3181568,
+    "memory.free_until_gc": 3181568,
+    "memory.free_until_oome": 196083712,
+    "memory.total": 7774208,
+    "memory.max": 201326592
+  },
   "browser":
   {
     "name": "e1c723db-7408-4043-baa7-f4e96234e5dc",

From 58e0436e7aa2f8c4d817a0846c5b448b7144aa04 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 26 May 2026 16:20:20 +0200
Subject: [PATCH 170/391] chore(build): Remove IDEA-316081 toolchain workaround
 (#5465)

The Gradle taskGraph workaround for the IntelliJ IDEA toolchain
bug (IDEA-316081) is no longer needed.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 build.gradle.kts | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 8df6e48fe53..d5b5dfc5d05 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -262,14 +262,6 @@ tasks.register("buildForCodeQL") {
         }
 }
 
-// Workaround for https://youtrack.jetbrains.com/issue/IDEA-316081/Gradle-8-toolchain-error-Toolchain-from-executable-property-does-not-match-toolchain-from-javaLauncher-property-when-different
-gradle.taskGraph.whenReady {
-    val task = this.allTasks.find { it.name.endsWith(".main()") } as? JavaExec
-    task?.let {
-        it.setExecutable(it.javaLauncher.get().executablePath.asFile.absolutePath)
-    }
-}
-
 /*
  * Adapted from https://github.com/androidx/androidx/blob/c799cba927a71f01ea6b421a8f83c181682633fb/buildSrc/private/src/main/kotlin/androidx/build/MavenUploadHelper.kt#L524-L549
  *

From 14c1d7e752c73c4a62a540ff3db3ce73c126669f Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 26 May 2026 18:31:54 +0200
Subject: [PATCH 171/391] feat(replay): Add ReplayFrameObserver for snapshot
 testing (#5386)

* feat(replay): Add beforeStoreFrame callback (JAVA-504)

Add an experimental callback that fires right before a replay frame is
stored to disk. The callback receives the masked bitmap (via Hint),
timestamp, and current screen name. This enables snapshot testing of
replay masking without needing to decode stored video segments.

Includes a Kotlin extension for ergonomic usage:
  options.sessionReplay.beforeStoreFrame { bitmap, ts, screen -> ... }

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* feat(replay): Add replay snapshot UI test with Sauce Labs collection (JAVA-504)

Add ReplaySnapshotTest that uses the beforeStoreFrame callback to
capture masked replay frames during a Compose UI test. Frames are
written to the Downloads/sauce_labs_custom_screenshots/ directory,
which is the standard path Sauce Labs collects screenshots from.

CI changes:
- Add *.png to Sauce Labs artifact match patterns
- Upload collected replay snapshots via sentry-cli build snapshots

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Use Java API in snapshot test to avoid extension dep (JAVA-504)

The Kotlin extension `beforeStoreFrame` comes from `sentry-android-replay`
which may not resolve in the UI test module. Use the Java callback API
directly instead.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Skip snapshot test on GH emulators and add changelog (JAVA-504)

GH Actions emulators don't support screenshot capture for replay,
so the ReplaySnapshotTest needs the same assumeThat guard used by
ReplayTest. Also adds a changelog entry for the beforeStoreFrame
callback.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Apply suggestion from @markushi

Co-authored-by: Markus Hintersteiner <markus.hintersteiner@sentry.io>

* refactor(replay): Replace beforeStoreFrame with ReplaySnapshotObserver (JAVA-504)

Move the frame observer API from the core sentry module to
sentry-android-replay so it can use Bitmap directly instead of
the Hint indirection. The new ReplaySnapshotObserver fun interface
lives in the replay module and is set on ReplayIntegration.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Mark ReplaySnapshotObserver as experimental and use Set in test (JAVA-504)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Add @ApiStatus.Experimental to ReplaySnapshotObserver (JAVA-504)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Make snapshotObserver public for cross-module access (JAVA-504)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Exclude ReplaySnapshotTest when integrations disabled (JAVA-504)

Move ReplaySnapshotTest to a conditional androidTestReplay source set
so it's only compiled when APPLY_SENTRY_INTEGRATIONS is true. The test
imports replay classes that aren't on the classpath otherwise.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Copy bitmap before passing to ReplaySnapshotObserver (JAVA-504)

Consumers of the observer API receive a copy of the bitmap instead of
the replay system's shared instance. This eliminates race conditions
and crashes when consumers store or use the bitmap asynchronously.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* refactor(replay): Move ReplaySnapshotObserver to SentryReplayOptions with Hint API (JAVA-504)

Move ReplaySnapshotObserver from the replay module to SentryReplayOptions
in the core module and change the callback signature to use Hint instead
of Bitmap. The bitmap is now accessible via TypeCheckHint.REPLAY_FRAME_BITMAP.

This allows configuring the observer during Sentry.init{} alongside other
replay options, removing the need to cast replayController to
ReplayIntegration.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Remove unnecessary jetbrains-annotations dependency (JAVA-504)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* refactor(replay): Rename ReplaySnapshotObserver to ReplayFrameObserver (JAVA-504)

Rename the interface to ReplayFrameObserver and the callback method
to onMaskedFrameCaptured to clarify that frames have masking applied.
Also update the changelog with a usage snippet.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Format code

* fix(replay): Call onMaskedFrameCaptured in File-based onScreenshotRecorded (JAVA-504)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(changelog): Move replay entry to Unreleased section (JAVA-504)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 .github/workflows/integration-tests-ui.yml    |  22 ++++
 .sauce/sentry-uitest-android-ui.yml           |   1 +
 CHANGELOG.md                                  |  23 ++++
 .../sentry-uitest-android/build.gradle.kts    |   4 +
 .../uitest/android/ReplaySnapshotTest.kt      |  71 ++++++++++++
 .../android/replay/ReplayIntegration.kt       |  38 ++++++-
 .../android/replay/ReplayIntegrationTest.kt   | 103 ++++++++++++++++++
 sentry/api/sentry.api                         |   7 ++
 .../java/io/sentry/SentryReplayOptions.java   |  48 ++++++++
 .../main/java/io/sentry/TypeCheckHint.java    |   3 +
 10 files changed, 319 insertions(+), 1 deletion(-)
 create mode 100644 sentry-android-integration-tests/sentry-uitest-android/src/androidTestReplay/java/io/sentry/uitest/android/ReplaySnapshotTest.kt

diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 0549577f629..5206a173362 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -73,6 +73,28 @@ jobs:
         if: env.SAUCE_USERNAME != null
 
 
+      - name: Install Sentry CLI
+        if: ${{ !cancelled() && env.SAUCE_USERNAME != null }}
+        run: curl -sL https://sentry.io/get-cli/ | bash
+
+      - name: Upload Replay Snapshots to Sentry
+        if: ${{ !cancelled() && env.SAUCE_USERNAME != null }}
+        run: |
+          shopt -s globstar nullglob
+          pngs=(artifacts/**/*.png)
+          if [ ${#pngs[@]} -gt 0 ]; then
+            mkdir -p replay-snapshots
+            cp "${pngs[@]}" replay-snapshots/
+            sentry-cli build snapshots ./replay-snapshots \
+              --app-id sentry-android-replay
+          else
+            echo "No replay snapshot files found, skipping upload"
+          fi
+        env:
+          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
+          SENTRY_ORG: sentry-sdks
+          SENTRY_PROJECT: sentry-android
+
       - name: Upload test results to Codecov
         if: ${{ !cancelled() }}
         uses: codecov/test-results-action@0fa95f0e1eeaafde2c782583b36b28ad0d8c77d3
diff --git a/.sauce/sentry-uitest-android-ui.yml b/.sauce/sentry-uitest-android-ui.yml
index 8d84f865c95..a00ee10614b 100644
--- a/.sauce/sentry-uitest-android-ui.yml
+++ b/.sauce/sentry-uitest-android-ui.yml
@@ -32,4 +32,5 @@ artifacts:
     when: always
     match:
       - junit.xml
+      - "*.png"
     directory: ./artifacts/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index acc07254df0..3c432e62410 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,28 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- Session Replay: Add `ReplayFrameObserver` for observing captured replay frames ([#5386](https://github.com/getsentry/sentry-java/pull/5386))
+
+  ```kotlin
+  SentryAndroid.init(context) { options ->
+    options.sessionReplay.frameObserver =
+      SentryReplayOptions.ReplayFrameObserver { hint, frameTimestamp, screenName ->
+        val bitmap = hint.getAs(TypeCheckHint.REPLAY_FRAME_BITMAP, Bitmap::class.java)
+        if (bitmap != null) {
+          try {
+            // Process the masked replay frame
+            myAnalyzer.processFrame(bitmap, frameTimestamp, screenName)
+          } finally {
+            bitmap.recycle()
+          }
+        }
+      }
+  }
+  ```
+
 ## 8.42.0
 
 ### Features
diff --git a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
index 5258a33f92a..1d725b0b595 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
@@ -83,6 +83,10 @@ android {
 
 val applySentryIntegrations = System.getenv("APPLY_SENTRY_INTEGRATIONS")?.toBoolean() ?: true
 
+if (applySentryIntegrations) {
+  android.sourceSets["androidTest"].java.srcDirs("src/androidTestReplay/java")
+}
+
 dependencies {
   implementation(
     kotlin(Config.kotlinStdLib, org.jetbrains.kotlin.config.KotlinCompilerVersion.VERSION)
diff --git a/sentry-android-integration-tests/sentry-uitest-android/src/androidTestReplay/java/io/sentry/uitest/android/ReplaySnapshotTest.kt b/sentry-android-integration-tests/sentry-uitest-android/src/androidTestReplay/java/io/sentry/uitest/android/ReplaySnapshotTest.kt
new file mode 100644
index 00000000000..1d82a3f8bc0
--- /dev/null
+++ b/sentry-android-integration-tests/sentry-uitest-android/src/androidTestReplay/java/io/sentry/uitest/android/ReplaySnapshotTest.kt
@@ -0,0 +1,71 @@
+package io.sentry.uitest.android
+
+import android.graphics.Bitmap
+import android.os.Environment
+import androidx.lifecycle.Lifecycle
+import androidx.test.core.app.launchActivity
+import io.sentry.SentryReplayOptions
+import io.sentry.TypeCheckHint
+import java.io.File
+import java.util.concurrent.CopyOnWriteArraySet
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import kotlin.test.Test
+import kotlin.test.assertTrue
+import org.hamcrest.CoreMatchers.`is`
+import org.junit.Assume.assumeThat
+import org.junit.Before
+
+class ReplaySnapshotTest : BaseUiTest() {
+
+  @Before
+  fun setup() {
+    // GH Actions emulators don't support capturing screenshots for replay
+    @Suppress("KotlinConstantConditions")
+    assumeThat(BuildConfig.ENVIRONMENT != "github", `is`(true))
+  }
+
+  @Test
+  fun captureComposeReplayFrameSnapshots() {
+    val snapshotsDir =
+      File(
+          Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS),
+          "sauce_labs_custom_screenshots",
+        )
+        .apply {
+          deleteRecursively()
+          mkdirs()
+        }
+    val frameReceived = CountDownLatch(1)
+    val capturedScreens = CopyOnWriteArraySet<String>()
+
+    val activityScenario = launchActivity<ComposeActivity>()
+    activityScenario.moveToState(Lifecycle.State.RESUMED)
+
+    initSentry {
+      it.sessionReplay.sessionSampleRate = 1.0
+      it.sessionReplay.frameObserver =
+        SentryReplayOptions.ReplayFrameObserver { hint, frameTimestamp, screenName ->
+          val bitmap =
+            hint.getAs(TypeCheckHint.REPLAY_FRAME_BITMAP, Bitmap::class.java)
+              ?: return@ReplayFrameObserver
+          val name = screenName ?: "unknown"
+          if (capturedScreens.add(name)) {
+            val file = File(snapshotsDir, "${name}_$frameTimestamp.png")
+            file.outputStream().use { out -> bitmap.compress(Bitmap.CompressFormat.PNG, 100, out) }
+          }
+          bitmap.recycle()
+          frameReceived.countDown()
+        }
+    }
+
+    assertTrue(frameReceived.await(10, TimeUnit.SECONDS), "Expected at least one replay frame")
+    assertTrue(capturedScreens.isNotEmpty(), "Expected at least one screen captured")
+
+    val files = snapshotsDir.listFiles()?.filter { it.extension == "png" } ?: emptyList()
+    assertTrue(files.isNotEmpty(), "Expected snapshot PNG files on disk")
+    assertTrue(files.all { it.length() > 0 }, "Snapshot files should not be empty")
+
+    activityScenario.moveToState(Lifecycle.State.DESTROYED)
+  }
+}
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
index d25827e3c7d..07e91d76486 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
@@ -2,11 +2,13 @@ package io.sentry.android.replay
 
 import android.content.Context
 import android.graphics.Bitmap
+import android.graphics.BitmapFactory
 import android.os.Build
 import android.view.MotionEvent
 import io.sentry.Breadcrumb
 import io.sentry.DataCategory.All
 import io.sentry.DataCategory.Replay
+import io.sentry.Hint
 import io.sentry.IConnectionStatusProvider.ConnectionStatus
 import io.sentry.IConnectionStatusProvider.ConnectionStatus.DISCONNECTED
 import io.sentry.IConnectionStatusProvider.IConnectionStatusObserver
@@ -17,8 +19,10 @@ import io.sentry.ReplayBreadcrumbConverter
 import io.sentry.ReplayController
 import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.SentryLevel.DEBUG
+import io.sentry.SentryLevel.ERROR
 import io.sentry.SentryLevel.INFO
 import io.sentry.SentryOptions
+import io.sentry.TypeCheckHint
 import io.sentry.android.replay.ReplayState.CLOSED
 import io.sentry.android.replay.ReplayState.PAUSED
 import io.sentry.android.replay.ReplayState.RESUMED
@@ -308,13 +312,45 @@ public class ReplayIntegration(
     var screen: String? = null
     scopes?.configureScope { screen = it.screen?.substringAfterLast('.') }
     captureStrategy?.onScreenshotRecorded(bitmap) { frameTimeStamp ->
+      val observer = options.sessionReplay.frameObserver
+      if (observer != null) {
+        val copy = bitmap.copy(bitmap.config!!, false)
+        if (copy != null) {
+          try {
+            val hint = Hint()
+            hint.set(TypeCheckHint.REPLAY_FRAME_BITMAP, copy)
+            observer.onMaskedFrameCaptured(hint, frameTimeStamp, screen)
+          } catch (e: Throwable) {
+            options.logger.log(ERROR, "Error in ReplayFrameObserver", e)
+            copy.recycle()
+          }
+        }
+      }
       addFrame(bitmap, frameTimeStamp, screen)
     }
     checkCanRecord()
   }
 
   override fun onScreenshotRecorded(screenshot: File, frameTimestamp: Long) {
-    captureStrategy?.onScreenshotRecorded { _ -> addFrame(screenshot, frameTimestamp) }
+    var screen: String? = null
+    scopes?.configureScope { screen = it.screen?.substringAfterLast('.') }
+    captureStrategy?.onScreenshotRecorded { _ ->
+      val observer = options.sessionReplay.frameObserver
+      if (observer != null) {
+        val bitmap = BitmapFactory.decodeFile(screenshot.absolutePath)
+        if (bitmap != null) {
+          try {
+            val hint = Hint()
+            hint.set(TypeCheckHint.REPLAY_FRAME_BITMAP, bitmap)
+            observer.onMaskedFrameCaptured(hint, frameTimestamp, screen)
+          } catch (e: Throwable) {
+            options.logger.log(ERROR, "Error in ReplayFrameObserver", e)
+            bitmap.recycle()
+          }
+        }
+      }
+      addFrame(screenshot, frameTimestamp, screen)
+    }
     checkCanRecord()
   }
 
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
index 7c86a0ad010..4183fad10ed 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
@@ -18,6 +18,8 @@ import io.sentry.SentryEvent
 import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.SentryOptions
 import io.sentry.SentryReplayEvent.ReplayType
+import io.sentry.SentryReplayOptions
+import io.sentry.TypeCheckHint
 import io.sentry.android.replay.ReplayCache.Companion.ONGOING_SEGMENT
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_BIT_RATE
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_FRAME_RATE
@@ -63,6 +65,7 @@ import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.argThat
 import org.mockito.kotlin.check
 import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
@@ -969,6 +972,106 @@ class ReplayIntegrationTest {
     assertFalse(replay.isDebugMaskingOverlayEnabled)
   }
 
+  @Test
+  fun `snapshot observer is invoked with bitmap and metadata`() {
+    var callbackInvoked = false
+    var receivedTimestamp = 0L
+    var receivedScreen: String? = null
+    var receivedBitmap: Bitmap? = null
+
+    val captureStrategy =
+      mock<CaptureStrategy> {
+        doAnswer {
+            ((it.arguments[1] as ReplayCache.(frameTimestamp: Long) -> Unit)).invoke(
+              fixture.replayCache,
+              1720693523997,
+            )
+          }
+          .whenever(mock)
+          .onScreenshotRecorded(anyOrNull<Bitmap>(), any())
+      }
+    val replay = fixture.getSut(context, replayCaptureStrategyProvider = { captureStrategy })
+
+    fixture.scopes.configureScope { it.screen = "MainActivity" }
+    replay.register(fixture.scopes, fixture.options)
+    replay.start()
+
+    fixture.options.sessionReplay.frameObserver =
+      SentryReplayOptions.ReplayFrameObserver { hint, frameTimestamp, screenName ->
+        callbackInvoked = true
+        receivedTimestamp = frameTimestamp
+        receivedScreen = screenName
+        receivedBitmap = hint.getAs(TypeCheckHint.REPLAY_FRAME_BITMAP, Bitmap::class.java)
+      }
+
+    val copyBitmap = mock<Bitmap>()
+    val sourceBitmap =
+      mock<Bitmap> {
+        on { config } doReturn ARGB_8888
+        on { copy(any(), any()) } doReturn copyBitmap
+      }
+    replay.onScreenshotRecorded(sourceBitmap)
+
+    assertTrue(callbackInvoked)
+    assertEquals(1720693523997, receivedTimestamp)
+    assertEquals("MainActivity", receivedScreen)
+    assertEquals(copyBitmap, receivedBitmap)
+  }
+
+  @Test
+  fun `snapshot observer exception does not prevent frame storage`() {
+    val captureStrategy =
+      mock<CaptureStrategy> {
+        doAnswer {
+            ((it.arguments[1] as ReplayCache.(frameTimestamp: Long) -> Unit)).invoke(
+              fixture.replayCache,
+              1720693523997,
+            )
+          }
+          .whenever(mock)
+          .onScreenshotRecorded(anyOrNull<Bitmap>(), any())
+      }
+    val replay = fixture.getSut(context, replayCaptureStrategyProvider = { captureStrategy })
+
+    replay.register(fixture.scopes, fixture.options)
+    replay.start()
+
+    fixture.options.sessionReplay.frameObserver =
+      SentryReplayOptions.ReplayFrameObserver { _, _, _ -> throw RuntimeException("test") }
+
+    val sourceBitmap =
+      mock<Bitmap> {
+        on { config } doReturn ARGB_8888
+        on { copy(any(), any()) } doReturn mock<Bitmap>()
+      }
+    replay.onScreenshotRecorded(sourceBitmap)
+
+    verify(fixture.replayCache).addFrame(any<Bitmap>(), any(), anyOrNull())
+  }
+
+  @Test
+  fun `snapshot observer is not invoked when null`() {
+    val captureStrategy =
+      mock<CaptureStrategy> {
+        doAnswer {
+            ((it.arguments[1] as ReplayCache.(frameTimestamp: Long) -> Unit)).invoke(
+              fixture.replayCache,
+              1720693523997,
+            )
+          }
+          .whenever(mock)
+          .onScreenshotRecorded(anyOrNull<Bitmap>(), any())
+      }
+    val replay = fixture.getSut(context, replayCaptureStrategyProvider = { captureStrategy })
+
+    replay.register(fixture.scopes, fixture.options)
+    replay.start()
+
+    replay.onScreenshotRecorded(mock<Bitmap>())
+
+    verify(fixture.replayCache).addFrame(any<Bitmap>(), any(), anyOrNull())
+  }
+
   private fun getSessionCaptureStrategy(options: SentryOptions): SessionCaptureStrategy =
     SessionCaptureStrategy(
       options,
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index d2fd5f75dbc..cb03d8fe708 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -4063,6 +4063,7 @@ public final class io/sentry/SentryReplayOptions : io/sentry/SentryMaskingOption
 	public fun addUnmaskViewClass (Ljava/lang/String;)V
 	public fun getBeforeErrorSampling ()Lio/sentry/SentryReplayOptions$BeforeErrorSamplingCallback;
 	public fun getErrorReplayDuration ()J
+	public fun getFrameObserver ()Lio/sentry/SentryReplayOptions$ReplayFrameObserver;
 	public fun getFrameRate ()I
 	public fun getNetworkDetailAllowUrls ()Ljava/util/List;
 	public fun getNetworkDetailDenyUrls ()Ljava/util/List;
@@ -4085,6 +4086,7 @@ public final class io/sentry/SentryReplayOptions : io/sentry/SentryMaskingOption
 	public fun setBeforeErrorSampling (Lio/sentry/SentryReplayOptions$BeforeErrorSamplingCallback;)V
 	public fun setCaptureSurfaceViews (Z)V
 	public fun setDebug (Z)V
+	public fun setFrameObserver (Lio/sentry/SentryReplayOptions$ReplayFrameObserver;)V
 	public fun setMaskAllImages (Z)V
 	public fun setMaskAllText (Z)V
 	public fun setNetworkCaptureBodies (Z)V
@@ -4105,6 +4107,10 @@ public abstract interface class io/sentry/SentryReplayOptions$BeforeErrorSamplin
 	public abstract fun execute (Lio/sentry/SentryEvent;Lio/sentry/Hint;)Z
 }
 
+public abstract interface class io/sentry/SentryReplayOptions$ReplayFrameObserver {
+	public abstract fun onMaskedFrameCaptured (Lio/sentry/Hint;JLjava/lang/String;)V
+}
+
 public final class io/sentry/SentryReplayOptions$SentryReplayQuality : java/lang/Enum {
 	public static final field HIGH Lio/sentry/SentryReplayOptions$SentryReplayQuality;
 	public static final field LOW Lio/sentry/SentryReplayOptions$SentryReplayQuality;
@@ -4651,6 +4657,7 @@ public final class io/sentry/TypeCheckHint {
 	public static final field OKHTTP_RESPONSE Ljava/lang/String;
 	public static final field OPEN_FEIGN_REQUEST Ljava/lang/String;
 	public static final field OPEN_FEIGN_RESPONSE Ljava/lang/String;
+	public static final field REPLAY_FRAME_BITMAP Ljava/lang/String;
 	public static final field SENTRY_DART_SDK_NAME Ljava/lang/String;
 	public static final field SENTRY_DOTNET_SDK_NAME Ljava/lang/String;
 	public static final field SENTRY_EVENT_DROP_REASON Ljava/lang/String;
diff --git a/sentry/src/main/java/io/sentry/SentryReplayOptions.java b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
index 6eb4a58e1c2..d1da6510cdb 100644
--- a/sentry/src/main/java/io/sentry/SentryReplayOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
@@ -36,6 +36,30 @@ public interface BeforeErrorSamplingCallback {
     boolean execute(@NotNull SentryEvent event, @NotNull Hint hint);
   }
 
+  /**
+   * Observer that is notified when a masked replay frame is captured. The frame bitmap (with
+   * masking already applied) is passed via a {@link Hint} using the key {@link
+   * TypeCheckHint#REPLAY_FRAME_BITMAP}.
+   *
+   * <p>On Android, retrieve the bitmap with: {@code hint.getAs(TypeCheckHint.REPLAY_FRAME_BITMAP,
+   * Bitmap.class)}.
+   *
+   * <p>The callback runs on a background thread (replay executor). The bitmap is a copy owned by
+   * the caller. Call {@code Bitmap.recycle()} when done to free native memory.
+   */
+  @ApiStatus.Experimental
+  public interface ReplayFrameObserver {
+    /**
+     * Called when a masked replay frame is captured.
+     *
+     * @param hint contains the frame bitmap under {@link TypeCheckHint#REPLAY_FRAME_BITMAP}
+     * @param frameTimestamp the timestamp (in milliseconds since epoch) when the frame was captured
+     * @param screenName the current screen name, or {@code null} if unknown
+     */
+    void onMaskedFrameCaptured(
+        @NotNull Hint hint, long frameTimestamp, @Nullable String screenName);
+  }
+
   private static final String CUSTOM_MASKING_INTEGRATION_NAME = "ReplayCustomMasking";
   private volatile boolean customMaskingTracked = false;
 
@@ -211,6 +235,8 @@ public enum SentryReplayQuality {
    */
   private @Nullable BeforeErrorSamplingCallback beforeErrorSampling;
 
+  @ApiStatus.Experimental private @Nullable ReplayFrameObserver frameObserver;
+
   public SentryReplayOptions(final boolean empty, final @Nullable SdkVersion sdkVersion) {
     if (!empty) {
       // Add default mask classes directly without setting usingCustomMasking flag
@@ -550,4 +576,26 @@ public void setBeforeErrorSampling(
       final @Nullable BeforeErrorSamplingCallback beforeErrorSampling) {
     this.beforeErrorSampling = beforeErrorSampling;
   }
+
+  /**
+   * Gets the observer that is notified when a masked replay frame is captured.
+   *
+   * @return the observer, or {@code null} if not set
+   */
+  @ApiStatus.Experimental
+  public @Nullable ReplayFrameObserver getFrameObserver() {
+    return frameObserver;
+  }
+
+  /**
+   * Sets the observer that is notified when a masked replay frame is captured. The frame bitmap
+   * (with masking already applied) is passed via a {@link Hint} using the key {@link
+   * TypeCheckHint#REPLAY_FRAME_BITMAP}.
+   *
+   * @param frameObserver the observer, or {@code null} to clear
+   */
+  @ApiStatus.Experimental
+  public void setFrameObserver(final @Nullable ReplayFrameObserver frameObserver) {
+    this.frameObserver = frameObserver;
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/TypeCheckHint.java b/sentry/src/main/java/io/sentry/TypeCheckHint.java
index 189050570b4..b3b061e847c 100644
--- a/sentry/src/main/java/io/sentry/TypeCheckHint.java
+++ b/sentry/src/main/java/io/sentry/TypeCheckHint.java
@@ -140,4 +140,7 @@ public final class TypeCheckHint {
 
   /** Used for Ktor Request breadcrumbs. */
   public static final String KTOR_CLIENT_REQUEST = "ktorClient:request";
+
+  /** Used for Session Replay frame bitmaps in the ReplayFrameObserver callback. */
+  public static final String REPLAY_FRAME_BITMAP = "replay:frameBitmap";
 }

From b8ed47ac7f5486701a89e834a24d8e661ffbbec6 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 27 May 2026 17:26:10 +0200
Subject: [PATCH 172/391] chore(build): Apply Develocity build scans plugin
 (#5469)

* chore(build): Apply Develocity build scans plugin

Adds the com.gradle.develocity plugin to settings.gradle.kts
to publish a build scan on every Gradle invocation. This enables
build performance insights and debugging via scans.gradle.com.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ref(build): Remove redundant publishingOnlyIf

Publishing on every build is the default behavior once the terms
of use are accepted.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* chore(build): Apply common custom user data plugin

Adds the com.gradle.common-custom-user-data-gradle-plugin to
capture additional build metadata (Git, CI environment) in
Develocity build scans.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 settings.gradle.kts | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/settings.gradle.kts b/settings.gradle.kts
index 4b1c606bc64..c435c382b79 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -7,6 +7,18 @@ pluginManagement {
     }
 }
 
+plugins {
+    id("com.gradle.develocity") version "4.4.2"
+    id("com.gradle.common-custom-user-data-gradle-plugin") version "2.6.0"
+}
+
+develocity {
+    buildScan {
+        termsOfUseUrl.set("https://gradle.com/help/legal-terms-of-use")
+        termsOfUseAgree.set("yes")
+    }
+}
+
 dependencyResolutionManagement {
     repositories {
         google()

From a911f6daa9921a54b98a0b5f84e2b3c3d41a5c80 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 27 May 2026 17:28:02 +0200
Subject: [PATCH 173/391] fix(changelog): Move ART memory entry to unreleased
 (#5470)

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3c432e62410..684d2b68969 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,7 @@
       }
   }
   ```
+- Parse ART memory and garbage collector info from ANR tombstones into ART context ([#5428](https://github.com/getsentry/sentry-java/pull/5428))
 
 ## 8.42.0
 
@@ -31,7 +32,6 @@
   - Enable via `options.isAttachRawTombstone = true` or manifest: `<meta-data android:name="io.sentry.tombstone.attach-raw" android:value="true" />`
 - Add API to clear feature flags from scopes ([#5426](https://github.com/getsentry/sentry-java/pull/5426))
 - Add support to configure reporting historical ANRs via `AndroidManifest.xml` using the  `io.sentry.anr.report-historical` attribute ([#5387](https://github.com/getsentry/sentry-java/pull/5387))
-- Parse ART memory and garbage collector info from ANR tombstones into ART context ([#5428](https://github.com/getsentry/sentry-java/pull/5428))
 
 ### Dependencies
 

From c1702e5dd181f26299ae9251266b039a336e936e Mon Sep 17 00:00:00 2001
From: runningcode <332597+runningcode@users.noreply.github.com>
Date: Wed, 27 May 2026 15:29:25 +0000
Subject: [PATCH 174/391] release: 8.43.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 684d2b68969..c21a8cce7d7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.43.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 2eb795118a0..9739db8a573 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.42.0
+versionName=8.43.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From e5cd1c6063fb69b258319747582f627478860336 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Thu, 28 May 2026 10:10:46 +0200
Subject: [PATCH 175/391] ci: Fix Spring Boot matrix version updates (#5372)

* ci: Fix Spring Boot matrix version updates

Match the TOML version catalog format when overriding Spring Boot versions in matrix jobs. Preserve whitespace around the assignment and replace the quoted version value so the CI jobs actually test the requested matrix version.

Co-Authored-By: Claude <noreply@anthropic.com>

* ci: Limit Spring Boot matrix to supported versions

The matrix jobs now actually update the version catalog. Remove Spring Boot versions that the current sample setup cannot build with the repository's Spring GraphQL integrations and Gradle version.

Co-Authored-By: Claude <noreply@anthropic.com>

* ci(spring): Restore Spring Boot matrix coverage

Expand the Spring Boot 2 and 3 CI matrices to cover supported minor versions. Exclude GraphQL from Spring Boot 2 versions before 2.7 because the starter is unavailable there.

Keep the Spring Boot 3 Gradle plugin pinned to a Gradle-compatible version while importing the tested Spring Boot BOM in samples, so the matrix exercises the intended runtime dependencies.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring): Avoid deprecated Reactor scheduler in sample

Remove the explicit elastic scheduler from the Spring Boot WebFlux sample. Mono.delay already schedules the delayed work, and using Schedulers.elastic triggers deprecation warnings that fail CI under -Werror.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring): Exclude Kafka from old Boot 2 matrix

Spring Kafka sample support depends on newer Spring Boot 2 dependency management. Exclude Kafka sources, profile startup, and system tests when the matrix runs Boot 2 versions before 2.7.

Keep the system test classpath aligned with the SDK test helpers by importing the OkHttp and Jackson BOMs after the tested Spring Boot BOMs.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring): Support older Reactor WebFlux APIs

Spring Boot 2.1 and 2.2 use Reactor versions without Mono.doFirst or Schedulers.onScheduleHook. Avoid those calls in the Boot 2 WebFlux integration so old matrix jobs can start and serve requests.

Co-Authored-By: Claude <noreply@anthropic.com>

* ci(spring): Skip OTel no-agent sample on old Boot 2

Spring Boot 2.1 and 2.2 cannot parse newer OpenTelemetry auto-configuration classes during startup. Keep the matrix coverage for supported samples and skip the no-agent OTel sample for those versions.

Co-Authored-By: Claude <noreply@anthropic.com>

* ci(spring): Drop old Boot 2 matrix versions

Remove Spring Boot 2.1 and 2.2 from the matrix instead of carrying WebFlux compatibility changes for their older Reactor and Spring APIs.

Restore the WebFlux filter implementation now that those versions are no longer tested.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring): Restore WebFlux schedule hook registration

Revert the compatibility guard for Reactor versions that are no longer covered by the Spring Boot matrix.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring): Support older Spring GraphQL options API

Use the erased Consumer signature in the batch loader registry wrapper so the code compiles with both Spring GraphQL 1.2/1.3 and 1.4.

Let the Spring Boot 3 Gradle plugin follow the tested matrix version instead of pinning it separately.

Co-Authored-By: Claude <noreply@anthropic.com>

* build: Remove redundant test source set config

Gradle already includes src/test/java in the test source set by default. Remove explicit duplicate source set configuration from the Spring modules and samples touched by this PR.

Co-Authored-By: Claude <noreply@anthropic.com>

* style: Import Kotlin JVM target in Gradle scripts

Use the JvmTarget import in Spring Gradle scripts touched by this PR instead of repeating the fully qualified class name.

Co-Authored-By: Claude <noreply@anthropic.com>

* ci: Fail when Spring Boot version update misses

Use a replacement command that exits non-zero when the expected Spring Boot version entry is not found. This prevents matrix jobs from silently running against the wrong dependency version.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .github/workflows/spring-boot-2-matrix.yml    | 11 +++-
 .github/workflows/spring-boot-3-matrix.yml    |  7 +-
 .github/workflows/spring-boot-4-matrix.yml    |  5 +-
 gradle/libs.versions.toml                     |  1 +
 .../build.gradle.kts                          | 16 +++--
 .../build.gradle.kts                          | 15 +++--
 .../build.gradle.kts                          | 15 +++--
 .../build.gradle.kts                          | 65 ++++++++++++++-----
 .../build.gradle.kts                          | 63 ++++++++++++++----
 .../build.gradle.kts                          | 11 +++-
 .../build.gradle.kts                          | 41 ++++++++++--
 .../boot/DistributedTracingController.java    | 15 +++--
 .../samples/spring/boot/PersonService.java    |  2 -
 .../build.gradle.kts                          | 61 +++++++++++++----
 .../build.gradle.kts                          | 12 ++--
 .../sentry-samples-spring/build.gradle.kts    |  6 +-
 sentry-spring-boot/build.gradle.kts           |  7 +-
 .../spring/boot/SentryAutoConfiguration.java  | 14 ++--
 .../boot/SentrySpringVersionChecker.java      |  3 +-
 .../graphql/SentryBatchLoaderRegistry.java    |  4 +-
 sentry-spring/build.gradle.kts                |  7 +-
 test/system-test-runner.py                    |  7 +-
 22 files changed, 272 insertions(+), 116 deletions(-)

diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 9a69765657c..48ed0a69665 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -21,7 +21,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        springboot-version: [ '2.1.0', '2.2.5', '2.4.13', '2.5.15', '2.6.15', '2.7.0', '2.7.18' ]
+        springboot-version: [ '2.4.13', '2.5.15', '2.6.15', '2.7.0', '2.7.18' ]
 
     name: Spring Boot ${{ matrix.springboot-version }}
     env:
@@ -64,8 +64,13 @@ jobs:
 
       - name: Update Spring Boot 2.x version
         run: |
-          sed -i 's/^springboot2=.*/springboot2=${{ matrix.springboot-version }}/' gradle/libs.versions.toml
-          echo "Updated Spring Boot 2.x version to ${{ matrix.springboot-version }}"
+          springboot_version="${{ matrix.springboot-version }}"
+          if [[ ! "$springboot_version" =~ ^2\.7\. ]]; then
+            echo "ORG_GRADLE_PROJECT_excludeGraphql=true" >> "$GITHUB_ENV"
+            echo "ORG_GRADLE_PROJECT_excludeKafka=true" >> "$GITHUB_ENV"
+          fi
+          perl -0pi -e 'BEGIN { $v = shift } s/^springboot2[[:space:]]*=[[:space:]]*"\K[^"]*/$v/m or die "::error::springboot2 version entry not found in gradle/libs.versions.toml\n"' "$springboot_version" gradle/libs.versions.toml
+          echo "Updated Spring Boot 2.x version to $springboot_version"
 
       - name: Exclude android modules from build
         run: |
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index c6a83c597fb..0e00608efe2 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -21,7 +21,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        springboot-version: [ '3.0.0', '3.2.12', '3.3.13', '3.4.13', '3.5.13' ]
+        springboot-version: [ '3.2.12', '3.3.13', '3.4.13', '3.5.13' ]
 
     name: Spring Boot ${{ matrix.springboot-version }}
     env:
@@ -64,8 +64,9 @@ jobs:
 
       - name: Update Spring Boot 3.x version
         run: |
-          sed -i 's/^springboot3=.*/springboot3=${{ matrix.springboot-version }}/' gradle/libs.versions.toml
-          echo "Updated Spring Boot 3.x version to ${{ matrix.springboot-version }}"
+          springboot_version="${{ matrix.springboot-version }}"
+          perl -0pi -e 'BEGIN { $v = shift } s/^springboot3[[:space:]]*=[[:space:]]*"\K[^"]*/$v/m or die "::error::springboot3 version entry not found in gradle/libs.versions.toml\n"' "$springboot_version" gradle/libs.versions.toml
+          echo "Updated Spring Boot 3.x version to $springboot_version"
 
       - name: Exclude android modules from build
         run: |
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 93d314de2e3..c6ae6195f59 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -64,8 +64,9 @@ jobs:
 
       - name: Update Spring Boot 4.x version
         run: |
-          sed -i 's/^springboot4=.*/springboot4=${{ matrix.springboot-version }}/' gradle/libs.versions.toml
-          echo "Updated Spring Boot 4.x version to ${{ matrix.springboot-version }}"
+          springboot_version="${{ matrix.springboot-version }}"
+          perl -0pi -e 'BEGIN { $v = shift } s/^springboot4[[:space:]]*=[[:space:]]*"\K[^"]*/$v/m or die "::error::springboot4 version entry not found in gradle/libs.versions.toml\n"' "$springboot_version" gradle/libs.versions.toml
+          echo "Updated Spring Boot 4.x version to $springboot_version"
 
       - name: Exclude android modules from build
         run: |
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 4e580db7498..12e24536d7e 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -160,6 +160,7 @@ slf4j2-api = { module = "org.slf4j:slf4j-api", version = "2.0.5" }
 spotlessLib = { module = "com.diffplug.spotless:com.diffplug.spotless.gradle.plugin", version.ref = "spotless"}
 springboot2-bom = { module = "org.springframework.boot:spring-boot-dependencies", version.ref = "springboot2" }
 springboot-starter = { module = "org.springframework.boot:spring-boot-starter", version.ref = "springboot2" }
+spring-graphql = { module = "org.springframework.graphql:spring-graphql", version = "1.0.6" }
 springboot-starter-graphql = { module = "org.springframework.boot:spring-boot-starter-graphql", version.ref = "springboot2" }
 springboot-starter-quartz = { module = "org.springframework.boot:spring-boot-starter-quartz", version.ref = "springboot2" }
 springboot-starter-test = { module = "org.springframework.boot:spring-boot-starter-test", version.ref = "springboot2" }
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
index ed0af32b031..7966e621ebd 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
@@ -1,4 +1,5 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -18,6 +19,13 @@ java.targetCompatibility = JavaVersion.VERSION_17
 
 repositories { mavenCentral() }
 
+dependencyManagement {
+  imports {
+    mavenBom("org.springframework.boot:spring-boot-dependencies:${libs.versions.springboot3.get()}")
+    mavenBom(libs.otel.instrumentation.bom.get().toString())
+  }
+}
+
 // Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
 extra["kotlin-coroutines.version"] = "1.9.0"
 
@@ -27,10 +35,10 @@ configure<JavaPluginExtension> {
 }
 
 tasks.withType<KotlinCompile>().configureEach {
-  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+  compilerOptions.jvmTarget = JvmTarget.JVM_17
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.jvmTarget = JvmTarget.JVM_17
   }
 }
 
@@ -79,10 +87,6 @@ dependencies {
   testImplementation("ch.qos.logback:logback-core:1.5.16")
 }
 
-dependencyManagement { imports { mavenBom(libs.otel.instrumentation.bom.get().toString()) } }
-
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
index d3d66c469b7..3c7e00ae552 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
@@ -1,4 +1,5 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.springframework.boot.gradle.tasks.run.BootRun
 
@@ -19,6 +20,12 @@ java.targetCompatibility = JavaVersion.VERSION_17
 
 repositories { mavenCentral() }
 
+dependencyManagement {
+  imports {
+    mavenBom("org.springframework.boot:spring-boot-dependencies:${libs.versions.springboot3.get()}")
+  }
+}
+
 // Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
 extra["kotlin-coroutines.version"] = "1.9.0"
 
@@ -27,14 +34,12 @@ configure<JavaPluginExtension> {
   targetCompatibility = JavaVersion.VERSION_17
 }
 
-tasks.withType<KotlinCompile>().configureEach {
-  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
-}
+tasks.withType<KotlinCompile>().configureEach { compilerOptions.jvmTarget = JvmTarget.JVM_17 }
 
 tasks.withType<KotlinCompile>().configureEach {
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.jvmTarget = JvmTarget.JVM_17
   }
 }
 
@@ -83,8 +88,6 @@ dependencies {
   testImplementation("ch.qos.logback:logback-core:1.5.16")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<BootRun>("bootRunWithAgent").configure {
   group = "application"
 
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
index ae3ef70ad70..d5e4caa595d 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
@@ -1,4 +1,5 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -18,6 +19,12 @@ java.targetCompatibility = JavaVersion.VERSION_17
 
 repositories { mavenCentral() }
 
+dependencyManagement {
+  imports {
+    mavenBom("org.springframework.boot:spring-boot-dependencies:${libs.versions.springboot3.get()}")
+  }
+}
+
 // Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
 extra["kotlin-coroutines.version"] = "1.9.0"
 
@@ -26,14 +33,12 @@ configure<JavaPluginExtension> {
   targetCompatibility = JavaVersion.VERSION_17
 }
 
-tasks.withType<KotlinCompile>().configureEach {
-  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
-}
+tasks.withType<KotlinCompile>().configureEach { compilerOptions.jvmTarget = JvmTarget.JVM_17 }
 
 tasks.withType<KotlinCompile>().configureEach {
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.jvmTarget = JvmTarget.JVM_17
   }
 }
 
@@ -85,8 +90,6 @@ dependencies {
   testImplementation("ch.qos.logback:logback-core:1.5.16")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
index f1665f513d1..0b8c5a181e7 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
@@ -1,4 +1,5 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -15,25 +16,35 @@ group = "io.sentry.sample.spring-boot"
 
 version = "0.0.1-SNAPSHOT"
 
-java.sourceCompatibility = JavaVersion.VERSION_17
+java.sourceCompatibility = JavaVersion.VERSION_11
 
-java.targetCompatibility = JavaVersion.VERSION_17
+java.targetCompatibility = JavaVersion.VERSION_11
 
 repositories { mavenCentral() }
 
-configure<JavaPluginExtension> {
-  sourceCompatibility = JavaVersion.VERSION_17
-  targetCompatibility = JavaVersion.VERSION_17
+fun springBoot2SupportsOptionalIntegrations(): Boolean {
+  val version = libs.versions.springboot2.get().removeSuffix(".RELEASE")
+  val parts = version.split(".").map { it.toIntOrNull() ?: 0 }
+  val major = parts.getOrElse(0) { 0 }
+  val minor = parts.getOrElse(1) { 0 }
+  return major > 2 || (major == 2 && minor >= 7)
 }
 
-tasks.withType<KotlinCompile>().configureEach {
-  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+val includeGraphql =
+  !project.hasProperty("excludeGraphql") && springBoot2SupportsOptionalIntegrations()
+val includeKafka = !project.hasProperty("excludeKafka") && springBoot2SupportsOptionalIntegrations()
+
+configure<JavaPluginExtension> {
+  sourceCompatibility = JavaVersion.VERSION_11
+  targetCompatibility = JavaVersion.VERSION_11
 }
 
+tasks.withType<KotlinCompile>().configureEach { compilerOptions.jvmTarget = JvmTarget.JVM_11 }
+
 tasks.withType<KotlinCompile>().configureEach {
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.jvmTarget = JvmTarget.JVM_11
   }
 }
 
@@ -43,7 +54,9 @@ dependencies {
   implementation(libs.springboot.starter)
   implementation(libs.springboot.starter.actuator)
   implementation(libs.springboot.starter.aop)
-  implementation(libs.springboot.starter.graphql)
+  if (includeGraphql) {
+    implementation(libs.springboot.starter.graphql)
+  }
   implementation(libs.springboot.starter.jdbc)
   implementation(libs.springboot.starter.quartz)
   implementation(libs.springboot.starter.security)
@@ -55,14 +68,17 @@ dependencies {
   implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
   implementation(projects.sentrySpringBootStarter)
   implementation(projects.sentryLogback)
-  implementation(projects.sentryGraphql)
+  if (includeGraphql) {
+    implementation(projects.sentryGraphql)
+  }
   implementation(projects.sentryQuartz)
   implementation(projects.sentryOpentelemetry.sentryOpentelemetryAgentlessSpring)
   implementation(projects.sentryAsyncProfiler)
 
-  // kafka
-  implementation(libs.spring.kafka2)
-  implementation(projects.sentryKafka)
+  if (includeKafka) {
+    implementation(libs.spring.kafka2)
+    implementation(projects.sentryKafka)
+  }
 
   // database query tracing
   implementation(projects.sentryJdbc)
@@ -103,7 +119,18 @@ tasks.jar {
 
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
+configure<SourceSetContainer> {
+  main {
+    if (!includeGraphql) {
+      java.exclude("**/graphql/**")
+      resources.exclude("graphql/**")
+    }
+    if (!includeKafka) {
+      java.exclude("**/queues/kafka/**")
+      resources.exclude("application-kafka.properties")
+    }
+  }
+}
 
 tasks.register<Test>("systemTest").configure {
   group = "verification"
@@ -121,7 +148,15 @@ tasks.register<Test>("systemTest").configure {
   minHeapSize = "128m"
   maxHeapSize = "1g"
 
-  filter { includeTestsMatching("io.sentry.systemtest*") }
+  filter {
+    includeTestsMatching("io.sentry.systemtest*")
+    if (!includeGraphql) {
+      excludeTestsMatching("io.sentry.systemtest.Graphql*")
+    }
+    if (!includeKafka) {
+      excludeTestsMatching("io.sentry.systemtest.Kafka*")
+    }
+  }
 }
 
 tasks.named("test").configure {
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
index 7c84875ca07..b78f1f01881 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
@@ -1,4 +1,5 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -15,22 +16,34 @@ group = "io.sentry.sample.spring-boot"
 
 version = "0.0.1-SNAPSHOT"
 
-java.sourceCompatibility = JavaVersion.VERSION_17
+java.sourceCompatibility = JavaVersion.VERSION_11
 
-java.targetCompatibility = JavaVersion.VERSION_17
+java.targetCompatibility = JavaVersion.VERSION_11
 
 repositories { mavenCentral() }
 
+fun springBoot2SupportsOptionalIntegrations(): Boolean {
+  val version = libs.versions.springboot2.get().removeSuffix(".RELEASE")
+  val parts = version.split(".").map { it.toIntOrNull() ?: 0 }
+  val major = parts.getOrElse(0) { 0 }
+  val minor = parts.getOrElse(1) { 0 }
+  return major > 2 || (major == 2 && minor >= 7)
+}
+
+val includeGraphql =
+  !project.hasProperty("excludeGraphql") && springBoot2SupportsOptionalIntegrations()
+val includeKafka = !project.hasProperty("excludeKafka") && springBoot2SupportsOptionalIntegrations()
+
 configure<JavaPluginExtension> {
-  sourceCompatibility = JavaVersion.VERSION_17
-  targetCompatibility = JavaVersion.VERSION_17
+  sourceCompatibility = JavaVersion.VERSION_11
+  targetCompatibility = JavaVersion.VERSION_11
 }
 
 tasks.withType<KotlinCompile>().configureEach {
-  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+  compilerOptions.jvmTarget = JvmTarget.JVM_11
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.jvmTarget = JvmTarget.JVM_11
   }
 }
 
@@ -39,7 +52,9 @@ dependencies {
   implementation(libs.springboot.starter)
   implementation(libs.springboot.starter.actuator)
   implementation(libs.springboot.starter.aop)
-  implementation(libs.springboot.starter.graphql)
+  if (includeGraphql) {
+    implementation(libs.springboot.starter.graphql)
+  }
   implementation(libs.springboot.starter.jdbc)
   implementation(libs.springboot.starter.quartz)
   implementation(libs.springboot.starter.security)
@@ -51,14 +66,17 @@ dependencies {
   implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
   implementation(projects.sentrySpringBootStarter)
   implementation(projects.sentryLogback)
-  implementation(projects.sentryGraphql)
+  if (includeGraphql) {
+    implementation(projects.sentryGraphql)
+  }
   implementation(projects.sentryQuartz)
   implementation(projects.sentryAsyncProfiler)
   implementation(libs.otel)
 
-  // kafka
-  implementation(libs.spring.kafka2)
-  implementation(projects.sentryKafka)
+  if (includeKafka) {
+    implementation(libs.spring.kafka2)
+    implementation(projects.sentryKafka)
+  }
 
   // database query tracing
   implementation(projects.sentryJdbc)
@@ -99,7 +117,18 @@ tasks.jar {
 
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
+configure<SourceSetContainer> {
+  main {
+    if (!includeGraphql) {
+      java.exclude("**/graphql/**")
+      resources.exclude("graphql/**")
+    }
+    if (!includeKafka) {
+      java.exclude("**/queues/kafka/**")
+      resources.exclude("application-kafka.properties")
+    }
+  }
+}
 
 tasks.register<JavaExec>("bootRunWithAgent").configure {
   group = "application"
@@ -141,7 +170,15 @@ tasks.register<Test>("systemTest").configure {
   minHeapSize = "128m"
   maxHeapSize = "1g"
 
-  filter { includeTestsMatching("io.sentry.systemtest*") }
+  filter {
+    includeTestsMatching("io.sentry.systemtest*")
+    if (!includeGraphql) {
+      excludeTestsMatching("io.sentry.systemtest.Graphql*")
+    }
+    if (!includeKafka) {
+      excludeTestsMatching("io.sentry.systemtest.Kafka*")
+    }
+  }
 }
 
 tasks.named("test").configure {
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
index d5b04543576..8b2079ddd9c 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
@@ -1,4 +1,5 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -18,6 +19,12 @@ java.targetCompatibility = JavaVersion.VERSION_17
 
 repositories { mavenCentral() }
 
+dependencyManagement {
+  imports {
+    mavenBom("org.springframework.boot:spring-boot-dependencies:${libs.versions.springboot3.get()}")
+  }
+}
+
 // Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
 extra["kotlin-coroutines.version"] = "1.9.0"
 
@@ -50,12 +57,10 @@ dependencies {
   testImplementation("ch.qos.logback:logback-core:1.5.16")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<KotlinCompile>().configureEach {
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.jvmTarget = JvmTarget.JVM_17
   }
 }
 
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
index b10b30737d8..2127dbfd79f 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
@@ -1,4 +1,5 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -15,22 +16,36 @@ group = "io.sentry.sample.spring-boot"
 
 version = "0.0.1-SNAPSHOT"
 
-java.sourceCompatibility = JavaVersion.VERSION_17
+java.sourceCompatibility = JavaVersion.VERSION_11
 
-java.targetCompatibility = JavaVersion.VERSION_17
+java.targetCompatibility = JavaVersion.VERSION_11
 
 repositories { mavenCentral() }
 
+fun springBoot2SupportsGraphql(): Boolean {
+  val version = libs.versions.springboot2.get().removeSuffix(".RELEASE")
+  val parts = version.split(".").map { it.toIntOrNull() ?: 0 }
+  val major = parts.getOrElse(0) { 0 }
+  val minor = parts.getOrElse(1) { 0 }
+  return major > 2 || (major == 2 && minor >= 7)
+}
+
+val includeGraphql = !project.hasProperty("excludeGraphql") && springBoot2SupportsGraphql()
+
 dependencies {
   implementation(platform(libs.springboot2.bom))
   implementation(libs.springboot.starter.actuator)
-  implementation(libs.springboot.starter.graphql)
+  if (includeGraphql) {
+    implementation(libs.springboot.starter.graphql)
+  }
   implementation(libs.springboot.starter.webflux)
   implementation(Config.Libs.kotlinReflect)
   implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
   implementation(projects.sentrySpringBootStarter)
   implementation(projects.sentryLogback)
-  implementation(projects.sentryGraphql)
+  if (includeGraphql) {
+    implementation(projects.sentryGraphql)
+  }
   implementation(projects.sentryAsyncProfiler)
 
   testImplementation(kotlin(Config.kotlinStdLib))
@@ -68,12 +83,19 @@ tasks.jar {
 
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
+configure<SourceSetContainer> {
+  main {
+    if (!includeGraphql) {
+      java.exclude("**/graphql/**")
+      resources.exclude("graphql/**")
+    }
+  }
+}
 
 tasks.withType<KotlinCompile>().configureEach {
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.jvmTarget = JvmTarget.JVM_11
   }
 }
 
@@ -93,7 +115,12 @@ tasks.register<Test>("systemTest").configure {
   minHeapSize = "128m"
   maxHeapSize = "1g"
 
-  filter { includeTestsMatching("io.sentry.systemtest*") }
+  filter {
+    includeTestsMatching("io.sentry.systemtest*")
+    if (!includeGraphql) {
+      excludeTestsMatching("io.sentry.systemtest.Graphql*")
+    }
+  }
 }
 
 tasks.named("test").configure {
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/DistributedTracingController.java b/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/DistributedTracingController.java
index cd69d854006..4bd6bb77bfb 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/DistributedTracingController.java
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/DistributedTracingController.java
@@ -1,6 +1,7 @@
 package io.sentry.samples.spring.boot;
 
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.http.HttpHeaders;
@@ -17,6 +18,10 @@
 @RequestMapping("/tracing/")
 public class DistributedTracingController {
   private static final Logger LOGGER = LoggerFactory.getLogger(DistributedTracingController.class);
+  private static final String BASIC_AUTH =
+      "Basic "
+          + Base64.getEncoder().encodeToString("user:password".getBytes(StandardCharsets.UTF_8));
+
   private final WebClient webClient;
 
   public DistributedTracingController(WebClient webClient) {
@@ -28,9 +33,7 @@ Mono<Person> person(@PathVariable Long id) {
     return webClient
         .get()
         .uri("http://localhost:8080/person/{id}", id)
-        .header(
-            HttpHeaders.AUTHORIZATION,
-            "Basic " + HttpHeaders.encodeBasicAuth("user", "password", Charset.defaultCharset()))
+        .header(HttpHeaders.AUTHORIZATION, BASIC_AUTH)
         .retrieve()
         .bodyToMono(Person.class)
         .map(response -> response);
@@ -41,9 +44,7 @@ Mono<Person> create(@RequestBody Person person) {
     return webClient
         .post()
         .uri("http://localhost:8080/person/")
-        .header(
-            HttpHeaders.AUTHORIZATION,
-            "Basic " + HttpHeaders.encodeBasicAuth("user", "password", Charset.defaultCharset()))
+        .header(HttpHeaders.AUTHORIZATION, BASIC_AUTH)
         .body(Mono.just(person), Person.class)
         .retrieve()
         .bodyToMono(Person.class)
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/PersonService.java b/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/PersonService.java
index ed7422d9d0b..4a9ae98a447 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/PersonService.java
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/src/main/java/io/sentry/samples/spring/boot/PersonService.java
@@ -4,14 +4,12 @@
 import java.time.Duration;
 import org.springframework.stereotype.Service;
 import reactor.core.publisher.Mono;
-import reactor.core.scheduler.Schedulers;
 
 @Service
 public class PersonService {
 
   Mono<Person> create(Person person) {
     return Mono.delay(Duration.ofMillis(100))
-        .publishOn(Schedulers.boundedElastic())
         .doOnNext(__ -> Sentry.captureMessage("Creating person"))
         .map(__ -> person);
   }
diff --git a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
index cc535c725e1..0a2a6f2da57 100644
--- a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
@@ -1,4 +1,5 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -15,21 +16,33 @@ group = "io.sentry.sample.spring-boot"
 
 version = "0.0.1-SNAPSHOT"
 
-java.sourceCompatibility = JavaVersion.VERSION_17
+java.sourceCompatibility = JavaVersion.VERSION_11
 
-java.targetCompatibility = JavaVersion.VERSION_17
+java.targetCompatibility = JavaVersion.VERSION_11
 
 repositories { mavenCentral() }
 
+fun springBoot2SupportsOptionalIntegrations(): Boolean {
+  val version = libs.versions.springboot2.get().removeSuffix(".RELEASE")
+  val parts = version.split(".").map { it.toIntOrNull() ?: 0 }
+  val major = parts.getOrElse(0) { 0 }
+  val minor = parts.getOrElse(1) { 0 }
+  return major > 2 || (major == 2 && minor >= 7)
+}
+
+val includeGraphql =
+  !project.hasProperty("excludeGraphql") && springBoot2SupportsOptionalIntegrations()
+val includeKafka = !project.hasProperty("excludeKafka") && springBoot2SupportsOptionalIntegrations()
+
 configure<JavaPluginExtension> {
-  sourceCompatibility = JavaVersion.VERSION_17
-  targetCompatibility = JavaVersion.VERSION_17
+  sourceCompatibility = JavaVersion.VERSION_11
+  targetCompatibility = JavaVersion.VERSION_11
 }
 
 tasks.withType<KotlinCompile>().configureEach {
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.jvmTarget = JvmTarget.JVM_11
   }
 }
 
@@ -38,7 +51,9 @@ dependencies {
   implementation(libs.springboot.starter)
   implementation(libs.springboot.starter.actuator)
   implementation(libs.springboot.starter.aop)
-  implementation(libs.springboot.starter.graphql)
+  if (includeGraphql) {
+    implementation(libs.springboot.starter.graphql)
+  }
   implementation(libs.springboot.starter.jdbc)
   implementation(libs.springboot.starter.quartz)
   implementation(libs.springboot.starter.security)
@@ -48,15 +63,18 @@ dependencies {
   implementation(libs.springboot.starter.websocket)
   implementation(libs.caffeine)
 
-  // kafka
-  implementation(libs.spring.kafka2)
-  implementation(projects.sentryKafka)
+  if (includeKafka) {
+    implementation(libs.spring.kafka2)
+    implementation(projects.sentryKafka)
+  }
   implementation(Config.Libs.aspectj)
   implementation(Config.Libs.kotlinReflect)
   implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
   implementation(projects.sentrySpringBootStarter)
   implementation(projects.sentryLogback)
-  implementation(projects.sentryGraphql)
+  if (includeGraphql) {
+    implementation(projects.sentryGraphql)
+  }
   implementation(projects.sentryQuartz)
   implementation(projects.sentryAsyncProfiler)
 
@@ -102,7 +120,18 @@ tasks.jar {
 
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
+configure<SourceSetContainer> {
+  main {
+    if (!includeGraphql) {
+      java.exclude("**/graphql/**")
+      resources.exclude("graphql/**")
+    }
+    if (!includeKafka) {
+      java.exclude("**/queues/kafka/**")
+      resources.exclude("application-kafka.properties")
+    }
+  }
+}
 
 tasks.register<Test>("systemTest").configure {
   group = "verification"
@@ -120,7 +149,15 @@ tasks.register<Test>("systemTest").configure {
   minHeapSize = "128m"
   maxHeapSize = "1g"
 
-  filter { includeTestsMatching("io.sentry.systemtest*") }
+  filter {
+    includeTestsMatching("io.sentry.systemtest*")
+    if (!includeGraphql) {
+      excludeTestsMatching("io.sentry.systemtest.Graphql*")
+    }
+    if (!includeKafka) {
+      excludeTestsMatching("io.sentry.systemtest.Kafka*")
+    }
+  }
 }
 
 tasks.named("test").configure {
diff --git a/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
index 319431e71d2..3dec793e5c9 100644
--- a/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
@@ -1,9 +1,8 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-import org.springframework.boot.gradle.plugin.SpringBootPlugin
 
 plugins {
   application
-  alias(libs.plugins.springboot3) apply false
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
@@ -31,8 +30,9 @@ extra["kotlin-coroutines.version"] = "1.9.0"
 
 dependencyManagement {
   imports {
-    mavenBom(SpringBootPlugin.BOM_COORDINATES)
+    mavenBom("org.springframework.boot:spring-boot-dependencies:${libs.versions.springboot3.get()}")
     mavenBom(libs.kotlin.bom.get().toString())
+    mavenBom(libs.jackson.bom.get().toString())
   }
 }
 
@@ -57,7 +57,7 @@ dependencies {
 
   testImplementation(projects.sentrySystemTestSupport)
   testImplementation(libs.kotlin.test.junit)
-  testImplementation(libs.springboot.starter.test) {
+  testImplementation(libs.springboot3.starter.test) {
     exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
   }
 }
@@ -65,12 +65,10 @@ dependencies {
 tasks.withType<KotlinCompile>().configureEach {
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_17
+    compilerOptions.jvmTarget = JvmTarget.JVM_17
   }
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-spring/build.gradle.kts b/sentry-samples/sentry-samples-spring/build.gradle.kts
index 446baf3a696..02e7f632450 100644
--- a/sentry-samples/sentry-samples-spring/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring/build.gradle.kts
@@ -1,3 +1,4 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -33,6 +34,7 @@ dependencyManagement {
     mavenBom(libs.springboot2.bom.get().toString())
     mavenBom(libs.kotlin.bom.get().toString())
     mavenBom(libs.jackson.bom.get().toString())
+    mavenBom(libs.okhttp.bom.get().toString())
   }
 }
 
@@ -64,12 +66,10 @@ dependencies {
 tasks.withType<KotlinCompile>().configureEach {
   kotlin {
     compilerOptions.freeCompilerArgs = listOf("-Xjsr305=strict")
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
+    compilerOptions.jvmTarget = JvmTarget.JVM_1_8
   }
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-spring-boot/build.gradle.kts b/sentry-spring-boot/build.gradle.kts
index 74f5d7c87bb..e54112ae54c 100644
--- a/sentry-spring-boot/build.gradle.kts
+++ b/sentry-spring-boot/build.gradle.kts
@@ -1,4 +1,5 @@
 import net.ltgt.gradle.errorprone.errorprone
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -12,7 +13,7 @@ plugins {
 }
 
 tasks.withType<KotlinCompile>().configureEach {
-  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
+  compilerOptions.jvmTarget = JvmTarget.JVM_1_8
   compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
   compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
 }
@@ -35,7 +36,7 @@ dependencies {
   compileOnly(libs.servlet.api)
   compileOnly(libs.springboot.starter)
   compileOnly(libs.springboot.starter.aop)
-  compileOnly(libs.springboot.starter.graphql)
+  compileOnly(libs.spring.graphql)
   compileOnly(libs.springboot.starter.quartz)
   compileOnly(libs.springboot.starter.security)
   compileOnly(libs.spring.kafka2)
@@ -84,8 +85,6 @@ dependencies {
   testImplementation(projects.sentryAsyncProfiler)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 jacoco { toolVersion = libs.versions.jacoco.get() }
 
 tasks.jacocoTestReport {
diff --git a/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java b/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java
index c7d5a892e9f..f89f5c5bb31 100644
--- a/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java
+++ b/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentryAutoConfiguration.java
@@ -1,7 +1,6 @@
 package io.sentry.spring.boot;
 
 import com.jakewharton.nopen.annotation.Open;
-import graphql.GraphQLError;
 import io.sentry.EventProcessor;
 import io.sentry.IScopes;
 import io.sentry.ISpanFactory;
@@ -12,7 +11,6 @@
 import io.sentry.Sentry;
 import io.sentry.SentryIntegrationPackageStorage;
 import io.sentry.SentryOptions;
-import io.sentry.graphql.SentryGraphqlExceptionHandler;
 import io.sentry.protocol.SdkVersion;
 import io.sentry.quartz.SentryJobListener;
 import io.sentry.spring.ContextTagsEventProcessor;
@@ -75,7 +73,6 @@
 import org.springframework.core.Ordered;
 import org.springframework.core.annotation.Order;
 import org.springframework.core.env.Environment;
-import org.springframework.graphql.execution.DataFetcherExceptionResolverAdapter;
 import org.springframework.scheduling.quartz.SchedulerFactoryBean;
 import org.springframework.security.core.context.SecurityContextHolder;
 import org.springframework.web.client.RestTemplate;
@@ -203,11 +200,12 @@ static class ContextTagsEventProcessorConfiguration {
     @Configuration(proxyBeanMethods = false)
     @Import(SentryGraphqlAutoConfiguration.class)
     @Open
-    @ConditionalOnClass({
-      SentryGraphqlExceptionHandler.class,
-      DataFetcherExceptionResolverAdapter.class,
-      GraphQLError.class
-    })
+    @ConditionalOnClass(
+        name = {
+          "io.sentry.graphql.SentryGraphqlExceptionHandler",
+          "org.springframework.graphql.execution.DataFetcherExceptionResolverAdapter",
+          "graphql.GraphQLError"
+        })
     static class GraphqlConfiguration {}
 
     @Configuration(proxyBeanMethods = false)
diff --git a/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentrySpringVersionChecker.java b/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentrySpringVersionChecker.java
index 1cbcb4f090c..2da1a3dd8d9 100644
--- a/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentrySpringVersionChecker.java
+++ b/sentry-spring-boot/src/main/java/io/sentry/spring/boot/SentrySpringVersionChecker.java
@@ -14,7 +14,8 @@ final class SentrySpringVersionChecker
   @Override
   public void onApplicationEvent(ApplicationContextInitializedEvent event) {
 
-    if (!SpringBootVersion.getVersion().startsWith("2")) {
+    String springBootVersion = SpringBootVersion.getVersion();
+    if (springBootVersion != null && !springBootVersion.startsWith("2")) {
       logger.warn("############################### WARNING ###############################");
       logger.warn("##                                                                   ##");
       logger.warn("##            !Incompatible Spring Boot Version detected!            ##");
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/graphql/SentryBatchLoaderRegistry.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/graphql/SentryBatchLoaderRegistry.java
index a75aa281349..4e7c3665aae 100644
--- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/graphql/SentryBatchLoaderRegistry.java
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/graphql/SentryBatchLoaderRegistry.java
@@ -75,8 +75,8 @@ public BatchLoaderRegistry.RegistrationSpec<K, V> withName(String name) {
     }
 
     @Override
-    public BatchLoaderRegistry.RegistrationSpec<K, V> withOptions(
-        Consumer<DataLoaderOptions.Builder> optionsConsumer) {
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    public BatchLoaderRegistry.RegistrationSpec<K, V> withOptions(Consumer optionsConsumer) {
       return delegate.withOptions(optionsConsumer);
     }
 
diff --git a/sentry-spring/build.gradle.kts b/sentry-spring/build.gradle.kts
index c4c75cb5f07..64380f7e7f4 100644
--- a/sentry-spring/build.gradle.kts
+++ b/sentry-spring/build.gradle.kts
@@ -1,4 +1,5 @@
 import net.ltgt.gradle.errorprone.errorprone
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -12,7 +13,7 @@ plugins {
 }
 
 tasks.withType<KotlinCompile>().configureEach {
-  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
+  compilerOptions.jvmTarget = JvmTarget.JVM_1_8
   compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
   compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
 }
@@ -34,7 +35,7 @@ dependencies {
   compileOnly(libs.otel)
   compileOnly(libs.servlet.api)
   compileOnly(libs.slf4j.api)
-  compileOnly(libs.springboot.starter.graphql)
+  compileOnly(libs.spring.graphql)
   compileOnly(libs.springboot.starter.quartz)
   compileOnly(libs.spring.kafka2)
   compileOnly(projects.sentryOpentelemetry.sentryOpentelemetryAgentcustomization)
@@ -63,8 +64,6 @@ dependencies {
   testImplementation(libs.springboot.starter.webflux)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 jacoco { toolVersion = libs.versions.jacoco.get() }
 
 tasks.jacocoTestReport {
diff --git a/test/system-test-runner.py b/test/system-test-runner.py
index 784448715e9..7dd7530c8bd 100644
--- a/test/system-test-runner.py
+++ b/test/system-test-runner.py
@@ -224,11 +224,14 @@ def kill_process(self, pid: int, name: str) -> None:
         except (OSError, ProcessLookupError):
             print(f"Process {pid} was already dead")
 
+    def exclude_kafka(self) -> bool:
+        return os.environ.get("ORG_GRADLE_PROJECT_excludeKafka") == "true"
+
     def module_requires_kafka(self, sample_module: str) -> bool:
-        return sample_module in KAFKA_BROKER_REQUIRED_MODULES
+        return not self.exclude_kafka() and sample_module in KAFKA_BROKER_REQUIRED_MODULES
 
     def module_requires_kafka_profile(self, sample_module: str) -> bool:
-        return sample_module in KAFKA_PROFILE_REQUIRED_MODULES
+        return not self.exclude_kafka() and sample_module in KAFKA_PROFILE_REQUIRED_MODULES
 
     def wait_for_port(self, host: str, port: int, max_attempts: int = 20) -> bool:
         for _ in range(max_attempts):

From ca6b6d88192958c95ad9494d044c45dcc460c8e2 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Thu, 28 May 2026 10:11:26 +0200
Subject: [PATCH 176/391] fix(skill): Detect stacked PR context from branch
 (#5223)

* fix(skill): Detect stacked PR context from branch

Update the create-java-pr skill to infer standalone vs stacked PR mode\nfrom git branch and existing PR relationships.\n\nWhen running on main/master, default to standalone PR mode and only\nenter stack mode when explicitly requested by the user.\n\nCo-Authored-By: Claude <noreply@anthropic.com>

* fix(create-java-pr): Detect collection branches with downstream PRs

Check for downstream PRs even when the current branch already has a PR targeting main/master.

This prevents collection branches in a stacked PR flow from being misclassified as standalone PR context.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(create-java-pr): Map stack base detection to defined PR type

When downstream PRs are found for a branch, classify the result as an existing stack flow instead of an undefined "stack base context".

Clarify that the next PR in an existing stack can target either the previous stack PR branch or the collection branch, so all detection outcomes map to actionable PR types.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(skills): Add missing standalone PR fallback for fresh feature branches

The decision tree in create-java-pr Step 0 had a gap: when a non-main
branch has no existing PR and no downstream PRs target it, no outcome
was specified. This is the most common case (fresh feature branch).

Add explicit fallback to standalone PR context, matching the behavior
of the parallel branch where a PR exists with base main and no
downstream PRs.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .claude/skills/create-java-pr/SKILL.md | 45 ++++++++++++++++++++++----
 1 file changed, 39 insertions(+), 6 deletions(-)

diff --git a/.claude/skills/create-java-pr/SKILL.md b/.claude/skills/create-java-pr/SKILL.md
index 6d5bb34edb3..e2a9b9bc785 100644
--- a/.claude/skills/create-java-pr/SKILL.md
+++ b/.claude/skills/create-java-pr/SKILL.md
@@ -9,15 +9,48 @@ Prepare local changes and create a pull request for the sentry-java repo.
 
 **Required reading:** Before proceeding, read `.cursor/rules/pr.mdc` for the full PR and stacked PR workflow details. That file is the source of truth for PR conventions, stack comment format, branch naming, and merge strategy.
 
-## Step 0: Determine PR Type
+## Step 0: Determine PR Type From Git Branch Context
 
-Ask the user (or infer from context) whether this is:
+Infer PR type from the current branch before asking the user.
 
-- **Standalone PR** — a regular PR targeting `main`. Follow Steps 1–6 as written.
-- **First PR of a new stack** — ask for a topic name (e.g. "Global Attributes"). Create a collection branch from `main`, then branch the first PR off it. The first PR targets the collection branch.
-- **Next PR in an existing stack** — identify the previous stack branch and topic. This PR targets the previous stack branch.
+1. Get current branch:
 
-If the user mentions "stack", "stacked PR", or provides a topic name with a number (e.g. `[Topic 2]`), treat it as a stacked PR. See `.cursor/rules/pr.mdc` § "Stacked PRs" for full details.
+```bash
+git branch --show-current
+```
+
+2. Apply these rules:
+
+- **If branch is `main` or `master`**: default to a **standalone PR**.
+  - Do **not** assume stack mode from `main`.
+  - Only use stack mode if the user explicitly asks for a stacked PR.
+- **If branch is not `main`/`master`**:
+  - Check whether that branch already has a PR and what its base is:
+    ```bash
+    gh pr list --head "$(git branch --show-current)" --json number,baseRefName,title --jq '.[0]'
+    ```
+  - If that branch PR exists and `baseRefName` is **not** `main`/`master`, treat the work as a **stacked PR context**.
+  - If that branch PR exists and `baseRefName` **is** `main`/`master`, also check whether other PRs target the current branch:
+    ```bash
+    gh pr list --base "$(git branch --show-current)" --json number,headRefName,title
+    ```
+    - If there are downstream PRs, treat this as **next PR in an existing stack** with the current branch as the stack base (collection branch).
+    - If there are no downstream PRs, treat it as **standalone PR context**.
+  - If no PR exists for the current branch, check whether other PRs target it:
+    ```bash
+    gh pr list --base "$(git branch --show-current)" --json number,headRefName,title
+    ```
+    - If there are downstream PRs, treat this as **next PR in an existing stack** with the current branch as the stack base (collection branch).
+    - If there are no downstream PRs either, treat it as **standalone PR context** (fresh feature branch).
+
+3. If signals are mixed or ambiguous, ask one focused question to confirm.
+
+PR types:
+- **Standalone PR** — regular PR targeting `main`.
+- **First PR of a new stack** — create collection branch from `main`, then first PR off it.
+- **Next PR in an existing stack** — target the current stack base branch (usually the previous stack PR branch, or the collection branch if creating the first follow-up PR from the collection branch).
+
+If the user explicitly says "stack", "stacked PR", or provides numbered stack titles (e.g. `[Topic 2]`), honor that even if branch heuristics are inconclusive.
 
 ## Step 1: Ensure Feature Branch
 

From 9404243e2540f4ae8b6d734afb446c64bb976076 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 29 May 2026 08:33:54 +0200
Subject: [PATCH 177/391] chore(ci): Update gradle/actions from v5.0.2 to
 v6.1.0 (#5471)

* chore(ci): Update gradle/actions from v5.0.2 to v6.1.0

Remove stale workaround comments for gradle/actions#21 (now closed).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* Restore workaround comments

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/codeql-analysis.yml               | 2 +-
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 15 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 7ef34ea563e..f3ad7240438 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -39,7 +39,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index f5e89b2be40..6817ce53337 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -38,7 +38,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index ae8d78d305e..34bf6241fd6 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -31,7 +31,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index 1d1493bb7bf..23dd0134203 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
 
       - name: Set up Java
         uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index c338400f958..4109c2a2947 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -19,7 +19,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index b50d42f7d1d..090a6360745 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -20,7 +20,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
 
       - name: Generate Aggregate Javadocs
         run: |
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 2f5a63f747a..bbe8c709587 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -38,7 +38,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
@@ -88,7 +88,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index 1fd6c5c2c09..6d0aefab386 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -36,7 +36,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 4d6c952a161..85731127f36 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -36,7 +36,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 5206a173362..fbb8018da06 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -33,7 +33,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 3ba2d299e54..3fb0b162750 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -26,7 +26,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
 
       - name: Build artifacts
         run: make publish
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 48ed0a69665..91154a2c7b3 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -58,7 +58,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 0e00608efe2..f0b3fbe279b 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -58,7 +58,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index c6ae6195f59..68bdd38f2ec 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -58,7 +58,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index ea6a53a8750..fc66f6744b5 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -118,7 +118,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@0723195856401067f7a2779048b490ace7a47d7c
+        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 

From 4e3e79da82431a9fd3081a829281371c79709f19 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Fri, 29 May 2026 16:37:03 +0200
Subject: [PATCH 178/391] fix(replay): Associate trace IDs with replay segments
 (#5473)

* fix(replay): Populate trace_ids in replay events for trace search

When a transaction is captured while replay is recording, the trace ID
is now registered with the replay controller and included in the next
replay segment. This enables searching for replays by trace ID in the
Sentry UI.

Fixes #5346

Slack thread: https://sentry.slack.com/archives/CP4UUUF1S/p1779889727948439?thread_ts=1777385469.860819&cid=CP4UUUF1S

https://claude.ai/code/session_012wjHQtsEPzcrxSMCufxrDY

* docs: Add changelog entry for trace_ids fix

https://claude.ai/code/session_012wjHQtsEPzcrxSMCufxrDY

* Format code

* api dump

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |  6 ++
 .../api/sentry-android-replay.api             |  1 +
 .../android/replay/ReplayIntegration.kt       |  7 ++
 .../replay/capture/BaseCaptureStrategy.kt     | 29 ++++++-
 .../android/replay/capture/CaptureStrategy.kt |  6 ++
 .../android/replay/ReplayIntegrationTest.kt   | 32 ++++++++
 .../capture/SessionCaptureStrategyTest.kt     | 79 +++++++++++++++++++
 sentry/api/sentry.api                         |  2 +
 .../java/io/sentry/NoOpReplayController.java  |  3 +
 .../main/java/io/sentry/ReplayController.java |  8 ++
 .../src/main/java/io/sentry/SentryClient.java |  7 ++
 .../test/java/io/sentry/SentryClientTest.kt   | 17 ++++
 12 files changed, 195 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c21a8cce7d7..1bbbede5794 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Session Replay: Populate `trace_ids` in replay events to enable searching replays by trace ID ([#5473](https://github.com/getsentry/sentry-java/pull/5473))
+
 ## 8.43.0
 
 ### Features
diff --git a/sentry-android-replay/api/sentry-android-replay.api b/sentry-android-replay/api/sentry-android-replay.api
index aeabe9c05c1..12fe214176d 100644
--- a/sentry-android-replay/api/sentry-android-replay.api
+++ b/sentry-android-replay/api/sentry-android-replay.api
@@ -76,6 +76,7 @@ public final class io/sentry/android/replay/ReplayIntegration : io/sentry/IConne
 	public fun onWindowSizeChanged (II)V
 	public fun pause ()V
 	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
+	public fun registerTraceId (Lio/sentry/protocol/SentryId;)V
 	public fun resume ()V
 	public fun setBreadcrumbConverter (Lio/sentry/ReplayBreadcrumbConverter;)V
 	public fun start ()V
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
index 07e91d76486..116ab45af06 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
@@ -280,6 +280,13 @@ public class ReplayIntegration(
 
   override fun isDebugMaskingOverlayEnabled(): Boolean = debugMaskingEnabled
 
+  override fun registerTraceId(traceId: SentryId) {
+    if (!isEnabled.get() || !isRecording()) {
+      return
+    }
+    captureStrategy?.registerTraceId(traceId)
+  }
+
   private fun pauseInternal() {
     lifecycleLock.acquire().use {
       if (!isEnabled.get() || !lifecycle.isAllowed(PAUSED)) {
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
index 2277f6c33a1..dab98ec4e24 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
@@ -54,6 +54,8 @@ internal abstract class BaseCaptureStrategy(
 ) : CaptureStrategy {
   internal companion object {
     private const val TAG = "CaptureStrategy"
+    // https://github.com/getsentry/sentry-javascript/blob/30eb68fff5077211c30c61ba74625e66ab514870/packages/replay-internal/src/coreHandlers/handleAfterSendEvent.ts#L41
+    private const val MAX_TRACE_IDS = 100
   }
 
   private val persistingExecutor: ScheduledExecutorService by lazy {
@@ -96,6 +98,8 @@ internal abstract class BaseCaptureStrategy(
   override var replayType by persistableAtomic<ReplayType>(propertyName = SEGMENT_KEY_REPLAY_TYPE)
 
   protected val currentEvents: Deque<RRWebEvent> = ConcurrentLinkedDeque()
+  private val traceIdsLock = Any()
+  private val currentTraceIds: MutableList<String> = mutableListOf()
 
   override fun start(segmentId: Int, replayId: SentryId, replayType: ReplayType?) {
     cache = replayCacheProvider?.invoke(replayId) ?: ReplayCache(options, replayId)
@@ -135,8 +139,14 @@ internal abstract class BaseCaptureStrategy(
     screenAtStart: String? = this.screenAtStart,
     breadcrumbs: List<Breadcrumb>? = null,
     events: Deque<RRWebEvent> = this.currentEvents,
-  ): ReplaySegment =
-    createSegment(
+  ): ReplaySegment {
+    val traceIds =
+      synchronized(traceIdsLock) {
+        val ids = currentTraceIds.toList()
+        currentTraceIds.clear()
+        ids
+      }
+    return createSegment(
       scopes,
       options,
       duration,
@@ -152,7 +162,9 @@ internal abstract class BaseCaptureStrategy(
       screenAtStart,
       breadcrumbs,
       events,
+      traceIds,
     )
+  }
 
   override fun onConfigurationChanged(recorderConfig: ScreenshotRecorderConfig) {
     this.recorderConfig = recorderConfig
@@ -167,6 +179,19 @@ internal abstract class BaseCaptureStrategy(
     }
   }
 
+  override fun registerTraceId(traceId: SentryId) {
+    if (traceId != SentryId.EMPTY_ID) {
+      synchronized(traceIdsLock) {
+        if (currentTraceIds.size < MAX_TRACE_IDS) {
+          val id = traceId.toString()
+          if (!currentTraceIds.contains(id)) {
+            currentTraceIds.add(id)
+          }
+        }
+      }
+    }
+  }
+
   private class ReplayPersistingExecutorServiceThreadFactory : ThreadFactory {
     private var cnt = 0
 
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt
index 8e078161c15..6dc391a15ec 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt
@@ -53,6 +53,8 @@ internal interface CaptureStrategy {
 
   fun convert(): CaptureStrategy
 
+  fun registerTraceId(traceId: SentryId)
+
   companion object {
     private fun Breadcrumb?.isNetworkAvailable(): Boolean =
       this != null &&
@@ -84,6 +86,7 @@ internal interface CaptureStrategy {
       screenAtStart: String?,
       breadcrumbs: List<Breadcrumb>?,
       events: Deque<RRWebEvent>,
+      traceIds: List<String> = emptyList(),
     ): ReplaySegment {
       val generatedVideo =
         cache?.createVideoOf(
@@ -122,6 +125,7 @@ internal interface CaptureStrategy {
         screenAtStart,
         replayBreadcrumbs,
         events,
+        traceIds,
       )
     }
 
@@ -141,6 +145,7 @@ internal interface CaptureStrategy {
       screenAtStart: String?,
       breadcrumbs: List<Breadcrumb>,
       events: Deque<RRWebEvent>,
+      traceIds: List<String>,
     ): ReplaySegment {
       val endTimestamp = DateUtils.getDateTime(segmentTimestamp.time + videoDuration)
       val replay =
@@ -152,6 +157,7 @@ internal interface CaptureStrategy {
           this.replayStartTimestamp = segmentTimestamp
           this.replayType = replayType
           this.videoFile = video
+          this.traceIds = traceIds
         }
 
       val recordingPayload = mutableListOf<RRWebEvent>()
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
index 4183fad10ed..3df0c9f005f 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
@@ -1072,6 +1072,38 @@ class ReplayIntegrationTest {
     verify(fixture.replayCache).addFrame(any<Bitmap>(), any(), anyOrNull())
   }
 
+  @Test
+  fun `registerTraceId does nothing when replay is not started`() {
+    val replay = fixture.getSut(context)
+
+    replay.register(fixture.scopes, fixture.options)
+    // Don't call start()
+
+    // Should not throw
+    replay.registerTraceId(SentryId())
+  }
+
+  @Test
+  fun `registerTraceId forwards to capture strategy when recording`() {
+    var traceIdRegistered: SentryId? = null
+    val captureStrategy =
+      mock<CaptureStrategy> {
+        on { currentReplayId }.thenReturn(SentryId())
+        doAnswer { traceIdRegistered = it.arguments[0] as SentryId }
+          .whenever(mock)
+          .registerTraceId(any())
+      }
+    val replay = fixture.getSut(context, replayCaptureStrategyProvider = { captureStrategy })
+
+    replay.register(fixture.scopes, fixture.options)
+    replay.start()
+
+    val traceId = SentryId()
+    replay.registerTraceId(traceId)
+
+    assertEquals(traceId, traceIdRegistered)
+  }
+
   private fun getSessionCaptureStrategy(options: SentryOptions): SessionCaptureStrategy =
     SessionCaptureStrategy(
       options,
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt
index 9982c6623b2..b5a00bc624b 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt
@@ -475,4 +475,83 @@ class SessionCaptureStrategyTest {
         },
       )
   }
+
+  @Test
+  fun `registerTraceId includes trace IDs in next segment`() {
+    val now =
+      System.currentTimeMillis() + (fixture.options.sessionReplay.sessionSegmentDuration * 5)
+    val strategy = fixture.getSut(dateProvider = { now })
+    strategy.start()
+    strategy.onConfigurationChanged(fixture.recorderConfig)
+
+    val traceId1 = SentryId()
+    val traceId2 = SentryId()
+    strategy.registerTraceId(traceId1)
+    strategy.registerTraceId(traceId2)
+
+    strategy.onScreenshotRecorded(mock<Bitmap>()) {}
+
+    verify(fixture.scopes)
+      .captureReplay(
+        argThat { event ->
+          event is SentryReplayEvent &&
+            event.traceIds?.size == 2 &&
+            event.traceIds!!.contains(traceId1.toString()) &&
+            event.traceIds!!.contains(traceId2.toString())
+        },
+        any(),
+      )
+  }
+
+  @Test
+  fun `registerTraceId clears trace IDs after segment is created`() {
+    val now =
+      System.currentTimeMillis() + (fixture.options.sessionReplay.sessionSegmentDuration * 5)
+    val strategy = fixture.getSut(dateProvider = { now })
+    strategy.start()
+    strategy.onConfigurationChanged(fixture.recorderConfig)
+
+    val traceId = SentryId()
+    strategy.registerTraceId(traceId)
+
+    strategy.onScreenshotRecorded(mock<Bitmap>()) {}
+
+    verify(fixture.scopes)
+      .captureReplay(
+        argThat { event ->
+          event is SentryReplayEvent && event.traceIds?.contains(traceId.toString()) == true
+        },
+        any(),
+      )
+
+    // trigger another segment, trace IDs should be cleared
+    strategy.onScreenshotRecorded(mock<Bitmap>()) {}
+
+    verify(fixture.scopes)
+      .captureReplay(
+        argThat { event ->
+          event is SentryReplayEvent && event.segmentId == 1 && event.traceIds.isNullOrEmpty()
+        },
+        any(),
+      )
+  }
+
+  @Test
+  fun `registerTraceId ignores empty trace ID`() {
+    val now =
+      System.currentTimeMillis() + (fixture.options.sessionReplay.sessionSegmentDuration * 5)
+    val strategy = fixture.getSut(dateProvider = { now })
+    strategy.start()
+    strategy.onConfigurationChanged(fixture.recorderConfig)
+
+    strategy.registerTraceId(SentryId.EMPTY_ID)
+
+    strategy.onScreenshotRecorded(mock<Bitmap>()) {}
+
+    verify(fixture.scopes)
+      .captureReplay(
+        argThat { event -> event is SentryReplayEvent && event.traceIds.isNullOrEmpty() },
+        any(),
+      )
+  }
 }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index cb03d8fe708..4757be4894a 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -1703,6 +1703,7 @@ public final class io/sentry/NoOpReplayController : io/sentry/ReplayController {
 	public fun isDebugMaskingOverlayEnabled ()Z
 	public fun isRecording ()Z
 	public fun pause ()V
+	public fun registerTraceId (Lio/sentry/protocol/SentryId;)V
 	public fun resume ()V
 	public fun setBreadcrumbConverter (Lio/sentry/ReplayBreadcrumbConverter;)V
 	public fun start ()V
@@ -2344,6 +2345,7 @@ public abstract interface class io/sentry/ReplayController : io/sentry/IReplayAp
 	public abstract fun isDebugMaskingOverlayEnabled ()Z
 	public abstract fun isRecording ()Z
 	public abstract fun pause ()V
+	public abstract fun registerTraceId (Lio/sentry/protocol/SentryId;)V
 	public abstract fun resume ()V
 	public abstract fun setBreadcrumbConverter (Lio/sentry/ReplayBreadcrumbConverter;)V
 	public abstract fun start ()V
diff --git a/sentry/src/main/java/io/sentry/NoOpReplayController.java b/sentry/src/main/java/io/sentry/NoOpReplayController.java
index fec95b5d66d..2f6de9740d2 100644
--- a/sentry/src/main/java/io/sentry/NoOpReplayController.java
+++ b/sentry/src/main/java/io/sentry/NoOpReplayController.java
@@ -57,4 +57,7 @@ public void enableDebugMaskingOverlay() {}
 
   @Override
   public void disableDebugMaskingOverlay() {}
+
+  @Override
+  public void registerTraceId(@NotNull SentryId traceId) {}
 }
diff --git a/sentry/src/main/java/io/sentry/ReplayController.java b/sentry/src/main/java/io/sentry/ReplayController.java
index dd40bfc9732..f4baba40c9d 100644
--- a/sentry/src/main/java/io/sentry/ReplayController.java
+++ b/sentry/src/main/java/io/sentry/ReplayController.java
@@ -28,4 +28,12 @@ public interface ReplayController extends IReplayApi {
   ReplayBreadcrumbConverter getBreadcrumbConverter();
 
   boolean isDebugMaskingOverlayEnabled();
+
+  /**
+   * Registers a trace ID to be associated with the current replay. This is called when a
+   * transaction is captured while replay is recording, to enable searching for replays by trace ID.
+   *
+   * @param traceId the trace ID to associate with the current replay
+   */
+  void registerTraceId(@NotNull SentryId traceId);
 }
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index 6f328d0fd58..5ac81c44936 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -1043,6 +1043,13 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
       sentryId = SentryId.EMPTY_ID;
     }
 
+    if (!sentryId.equals(SentryId.EMPTY_ID)) {
+      final @Nullable SpanContext trace = transaction.getContexts().getTrace();
+      if (trace != null) {
+        options.getReplayController().registerTraceId(trace.getTraceId());
+      }
+    }
+
     return sentryId;
   }
 
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index 663b1f9bdee..d5b2f0f82a0 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -1958,6 +1958,23 @@ class SentryClientTest {
     assertEquals("abc", transaction.platform)
   }
 
+  @Test
+  fun `captureTransaction registers trace ID with replay controller`() {
+    var registeredTraceId: SentryId? = null
+    fixture.sentryOptions.setReplayController(
+      object : ReplayController by NoOpReplayController.getInstance() {
+        override fun registerTraceId(traceId: SentryId) {
+          registeredTraceId = traceId
+        }
+      }
+    )
+    val sut = fixture.getSut()
+    val sentryTracer = SentryTracer(TransactionContext("name", "op"), fixture.scopes)
+    val transaction = SentryTransaction(sentryTracer)
+    sut.captureTransaction(transaction, sentryTracer.traceContext())
+    assertEquals(sentryTracer.spanContext.traceId, registeredTraceId)
+  }
+
   @Test
   fun `when exception type is ignored, capturing event does not send it`() {
     fixture.sentryOptions.addIgnoredExceptionForType(IllegalStateException::class.java)

From b0aa73ebff17166a1a13d27e88b2dcdc13adf68c Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Tue, 2 Jun 2026 23:43:24 +0200
Subject: [PATCH 179/391] fix(replay): Keep replay recording during animations
 (#5489)

* fix(android): Keep replay capturing during animations

Skip only the first unstable PixelCopy capture, then continue emitting frames while the screen keeps invalidating. This prevents animated screens from freezing Session Replay visuals while preserving the existing debounce for one-off redraws.

Fixes GH-5404

Co-Authored-By: Codex <noreply@openai.com>

* test(android): Add replay animation sample screens

Add separate Android sample screens for Lottie, Compose canvas, and classic View animations so replay capture behavior can be tested manually.

Keep the sample app on the Canvas replay screenshot strategy while exercising these animations.

Refs GH-5404

Co-Authored-By: Codex <noreply@openai.com>

* changelog

* fix(android): Make replay animation sample colors API-safe

Use ContextCompat.getColor in ReplayAnimationsActivity so release lint passes with the sample app minSdk.

Refs GH-5489

Co-Authored-By: Codex <noreply@openai.com>

* docs(android): Explain unstable replay captures

Document why PixelCopyStrategy caps skipped unstable captures so continuous animations keep producing replay frames.

Refs GH-5489

Co-Authored-By: Codex <noreply@openai.com>

---------

Co-authored-by: Codex <noreply@openai.com>
---
 CHANGELOG.md                                  |   1 +
 gradle/libs.versions.toml                     |   2 +-
 .../replay/screenshot/PixelCopyStrategy.kt    |  63 +++-
 .../screenshot/PixelCopyStrategyTest.kt       | 114 +++++++
 .../sentry-samples-android/build.gradle.kts   |   1 +
 .../src/main/AndroidManifest.xml              |   4 +
 .../io/sentry/samples/android/MainActivity.kt |  12 +
 .../android/ReplayAnimationsActivity.kt       | 302 ++++++++++++++++++
 .../src/main/res/raw/replay_lottie_pulse.json | 181 +++++++++++
 9 files changed, 669 insertions(+), 11 deletions(-)
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ReplayAnimationsActivity.kt
 create mode 100644 sentry-samples/sentry-samples-android/src/main/res/raw/replay_lottie_pulse.json

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1bbbede5794..71bf01b7bf0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Session Replay: Fix replay recording freezing on screens with continuous animations ([#5489](https://github.com/getsentry/sentry-java/pull/5489))
 - Session Replay: Populate `trace_ids` in replay events to enable searching replays by trace ID ([#5473](https://github.com/getsentry/sentry-java/pull/5473))
 
 ## 8.43.0
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 12e24536d7e..7ee39d75ede 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -126,6 +126,7 @@ launchdarkly-server = { module = "com.launchdarkly:launchdarkly-java-server-sdk"
 log4j-api = { module = "org.apache.logging.log4j:log4j-api", version.ref = "log4j2" }
 log4j-core = { module = "org.apache.logging.log4j:log4j-core", version.ref = "log4j2" }
 leakcanary = { module = "com.squareup.leakcanary:leakcanary-android", version = "2.14" }
+lottie-compose = { module = "com.airbnb.android:lottie-compose", version = "6.7.1" }
 logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
 nopen-annotations = { module = "com.jakewharton.nopen:nopen-annotations", version.ref = "nopen" }
 nopen-checker = { module = "com.jakewharton.nopen:nopen-checker", version.ref = "nopen" }
@@ -248,4 +249,3 @@ msgpack = { module = "org.msgpack:msgpack-core", version = "0.9.8" }
 okhttp-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version.ref = "okhttp" }
 okio = { module = "com.squareup.okio:okio", version = "1.13.0" }
 roboelectric = { module = "org.robolectric:robolectric", version = "4.15" }
-
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
index 81dd7c5cee5..4b9618df6ec 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
@@ -40,6 +40,14 @@ internal class PixelCopyStrategy(
   private val markContentChanged: () -> Unit = {},
 ) : ScreenshotStrategy {
 
+  private companion object {
+    /**
+     * An unstable capture means the view hierarchy changed while PixelCopy was in flight. Cap
+     * skipped unstable captures so continuous animations don't stop replay recording.
+     */
+    const val MAX_UNSTABLE_CAPTURES_TO_SKIP = 1
+  }
+
   private val executor = executorProvider.getExecutor()
   private val mainLooperHandler = executorProvider.getMainLooperHandler()
   private val screenshot =
@@ -49,6 +57,7 @@ internal class PixelCopyStrategy(
   private val lastCaptureSuccessful = AtomicBoolean(false)
   private val maskRenderer = MaskRenderer()
   private val contentChanged = AtomicBoolean(false)
+  private val unstableCaptures = AtomicInteger(0)
   private val isClosed = AtomicBoolean(false)
   private val dstOverPaint by
     lazy(NONE) { Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OVER) } }
@@ -86,15 +95,13 @@ internal class PixelCopyStrategy(
 
           if (copyResult != PixelCopy.SUCCESS) {
             options.logger.log(INFO, "Failed to capture replay recording: %d", copyResult)
+            unstableCaptures.set(0)
             lastCaptureSuccessful.set(false)
             return@request
           }
 
-          // TODO: handle animations with heuristics (e.g. if we fall under this condition 2 times
-          // in a row, we should capture)
-          if (contentChanged.get()) {
-            options.logger.log(INFO, "Failed to determine view hierarchy, not capturing")
-            lastCaptureSuccessful.set(false)
+          val changedDuringCapture = contentChanged.get()
+          if (changedDuringCapture && shouldSkipUnstableCapture()) {
             return@request
           }
 
@@ -111,25 +118,48 @@ internal class PixelCopyStrategy(
           if (surfaceViewNodes.isNullOrEmpty()) {
             executor.submit(
               ReplayRunnable("screenshot_recorder.mask") {
-                applyMaskingAndNotify(root, viewHierarchy)
+                applyMaskingAndNotify(
+                  root,
+                  viewHierarchy,
+                  resetUnstableCaptures = !changedDuringCapture,
+                )
               }
             )
           } else {
             // Re-arm the recorder's contentChanged gate; SurfaceView redraws don't trigger
             // ViewTreeObserver.OnDrawListener, so we'd otherwise emit the same frame forever.
             markContentChanged()
-            captureSurfaceViews(root, surfaceViewNodes, viewHierarchy)
+            captureSurfaceViews(
+              root,
+              surfaceViewNodes,
+              viewHierarchy,
+              resetUnstableCaptures = !changedDuringCapture,
+            )
           }
         },
         mainLooperHandler.handler,
       )
     } catch (e: Throwable) {
       options.logger.log(WARNING, "Failed to capture replay recording", e)
+      unstableCaptures.set(0)
       lastCaptureSuccessful.set(false)
     }
   }
 
-  private fun applyMaskingAndNotify(root: View, viewHierarchy: ViewHierarchyNode) {
+  private fun shouldSkipUnstableCapture(): Boolean {
+    if (unstableCaptures.incrementAndGet() <= MAX_UNSTABLE_CAPTURES_TO_SKIP) {
+      options.logger.log(INFO, "Failed to determine view hierarchy, not capturing")
+      lastCaptureSuccessful.set(false)
+      return true
+    }
+    return false
+  }
+
+  private fun applyMaskingAndNotify(
+    root: View,
+    viewHierarchy: ViewHierarchyNode,
+    resetUnstableCaptures: Boolean,
+  ) {
     if (isClosed.get() || screenshot.isRecycled) {
       options.logger.log(DEBUG, "PixelCopyStrategy is closed, skipping masking")
       return
@@ -149,6 +179,9 @@ internal class PixelCopyStrategy(
     screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
     lastCaptureSuccessful.set(true)
     contentChanged.set(false)
+    if (resetUnstableCaptures) {
+      unstableCaptures.set(0)
+    }
   }
 
   @SuppressLint("NewApi")
@@ -156,6 +189,7 @@ internal class PixelCopyStrategy(
     root: View,
     surfaceViewNodes: List<ViewHierarchyNode.SurfaceViewHierarchyNode>,
     viewHierarchy: ViewHierarchyNode,
+    resetUnstableCaptures: Boolean,
   ) {
     // Snapshot the window location into locals so the executor-side compositor reads stable
     // values even if a new capture cycle starts and overwrites the field.
@@ -168,7 +202,14 @@ internal class PixelCopyStrategy(
 
     fun onCaptureComplete() {
       if (remaining.decrementAndGet() == 0) {
-        compositeSurfaceViewsAndMask(root, captures, viewHierarchy, windowX, windowY)
+        compositeSurfaceViewsAndMask(
+          root,
+          captures,
+          viewHierarchy,
+          windowX,
+          windowY,
+          resetUnstableCaptures,
+        )
       }
     }
 
@@ -229,6 +270,7 @@ internal class PixelCopyStrategy(
     viewHierarchy: ViewHierarchyNode,
     windowX: Int,
     windowY: Int,
+    resetUnstableCaptures: Boolean,
   ) {
     executor.submit(
       ReplayRunnable("screenshot_recorder.composite") {
@@ -258,7 +300,7 @@ internal class PixelCopyStrategy(
           capture.bitmap.recycle()
         }
 
-        applyMaskingAndNotify(root, viewHierarchy)
+        applyMaskingAndNotify(root, viewHierarchy, resetUnstableCaptures)
       }
     )
   }
@@ -287,6 +329,7 @@ internal class PixelCopyStrategy(
 
   override fun close() {
     isClosed.set(true)
+    unstableCaptures.set(0)
     executor.submit(
       ReplayRunnable(
         "PixelCopyStrategy.close",
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
index 277ad941a14..779cf7d4311 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
@@ -12,7 +12,10 @@ import android.graphics.RectF
 import android.os.Bundle
 import android.os.Handler
 import android.os.Looper
+import android.view.PixelCopy
 import android.view.SurfaceView
+import android.view.View
+import android.view.Window
 import android.widget.FrameLayout
 import android.widget.LinearLayout
 import android.widget.LinearLayout.LayoutParams
@@ -36,12 +39,16 @@ import org.junit.runner.RunWith
 import org.mockito.kotlin.any
 import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 import org.robolectric.Robolectric.buildActivity
 import org.robolectric.Shadows.shadowOf
 import org.robolectric.annotation.Config
 import org.robolectric.annotation.GraphicsMode
+import org.robolectric.annotation.Implementation
+import org.robolectric.annotation.Implements
 import org.robolectric.shadows.ShadowPixelCopy
 
 @Config(shadows = [ShadowPixelCopy::class], sdk = [30])
@@ -92,6 +99,7 @@ class PixelCopyStrategyTest {
   fun setup() {
     System.setProperty("robolectric.areWindowsMarkedVisible", "true")
     System.setProperty("robolectric.pixelCopyRenderMode", "hardware")
+    DeferredWindowPixelCopyShadow.reset()
   }
 
   @Test
@@ -132,6 +140,68 @@ class PixelCopyStrategyTest {
     if (failure.get() != null) throw failure.get()
   }
 
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `capture skips the first unstable PixelCopy result`() {
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    captureUnstableFrame(strategy, root)
+
+    assertFalse(strategy.lastCaptureSuccessful())
+    verify(fixture.callback, never()).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `capture emits the second consecutive unstable PixelCopy result`() {
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    captureUnstableFrame(strategy, root)
+    captureUnstableFrame(strategy, root)
+
+    assertTrue(strategy.lastCaptureSuccessful())
+    verify(fixture.callback).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `capture keeps emitting after entering continuous instability mode`() {
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    captureUnstableFrame(strategy, root)
+    captureUnstableFrame(strategy, root)
+    captureUnstableFrame(strategy, root)
+
+    assertTrue(strategy.lastCaptureSuccessful())
+    verify(fixture.callback, times(2)).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `stable capture resets the unstable PixelCopy counter`() {
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    captureUnstableFrame(strategy, root)
+    captureUnstableFrame(strategy, root)
+    captureStableFrame(strategy, root)
+    captureUnstableFrame(strategy, root)
+
+    assertFalse(strategy.lastCaptureSuccessful())
+    verify(fixture.callback, times(2)).onScreenshotRecorded(any<Bitmap>())
+  }
+
   @Test
   fun `capture does not call markContentChanged when option is disabled`() {
     val activity = buildActivity(ActivityWithSurfaceView::class.java).setup()
@@ -250,6 +320,50 @@ class PixelCopyStrategyTest {
     assertEquals(0, dest.getPixel(4, 4))
     assertEquals(0, dest.getPixel(25, 25))
   }
+
+  private fun captureUnstableFrame(strategy: PixelCopyStrategy, root: View) {
+    strategy.capture(root)
+    strategy.onContentChanged()
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+  }
+
+  private fun captureStableFrame(strategy: PixelCopyStrategy, root: View) {
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+  }
+}
+
+@Implements(PixelCopy::class)
+class DeferredWindowPixelCopyShadow {
+  companion object {
+    private val pendingCallbacks = mutableListOf<() -> Unit>()
+
+    fun reset() {
+      pendingCallbacks.clear()
+    }
+
+    fun flush() {
+      val callbacks = pendingCallbacks.toList()
+      pendingCallbacks.clear()
+      callbacks.forEach { it.invoke() }
+    }
+
+    @JvmStatic
+    @Implementation
+    @Suppress("UNUSED_PARAMETER")
+    fun request(
+      _source: Window,
+      _dest: Bitmap,
+      listener: PixelCopy.OnPixelCopyFinishedListener,
+      listenerThread: Handler,
+    ) {
+      pendingCallbacks.add {
+        listenerThread.post { listener.onPixelCopyFinished(PixelCopy.SUCCESS) }
+      }
+    }
+  }
 }
 
 private class SimpleActivity : Activity() {
diff --git a/sentry-samples/sentry-samples-android/build.gradle.kts b/sentry-samples/sentry-samples-android/build.gradle.kts
index bb2c3954ca6..ed8cea25661 100644
--- a/sentry-samples/sentry-samples-android/build.gradle.kts
+++ b/sentry-samples/sentry-samples-android/build.gradle.kts
@@ -150,6 +150,7 @@ dependencies {
   implementation(libs.androidx.browser)
   implementation(libs.coil.compose)
   implementation(libs.kotlinx.coroutines.android)
+  implementation(libs.lottie.compose)
   implementation(libs.retrofit)
   implementation(libs.retrofit.gson)
   implementation(libs.sentry.native.ndk)
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 26f526124b4..e5b5ed2250b 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -64,6 +64,10 @@
       android:name=".PermissionsActivity"
       android:exported="false" />
 
+    <activity
+      android:name=".ReplayAnimationsActivity"
+      android:exported="false" />
+
     <activity
       android:name=".ProfilingActivity"
       android:exported="false" />
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
index e000b54e4cc..86f1aace82e 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
@@ -498,6 +498,18 @@ fun SessionReplayScreen() {
         }
       }
     }
+    item {
+      SentryTraced("open_replay_animations") {
+        OutlinedButton(
+          onClick = {
+            activity.startActivity(Intent(activity, ReplayAnimationsActivity::class.java))
+          },
+          modifier = Modifier,
+        ) {
+          Text("Open Animations", maxLines = 2, overflow = TextOverflow.Ellipsis)
+        }
+      }
+    }
     item {
       SentryTraced("show_dialog") {
         OutlinedButton(onClick = { showDialog = true }, modifier = Modifier) {
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ReplayAnimationsActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ReplayAnimationsActivity.kt
new file mode 100644
index 00000000000..0fe6cda581f
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ReplayAnimationsActivity.kt
@@ -0,0 +1,302 @@
+package io.sentry.samples.android
+
+import android.animation.Animator
+import android.animation.ObjectAnimator
+import android.animation.ValueAnimator
+import android.content.Context
+import android.graphics.Color as AndroidColor
+import android.graphics.drawable.GradientDrawable
+import android.os.Bundle
+import android.view.Gravity
+import android.view.View
+import android.view.animation.LinearInterpolator
+import android.widget.FrameLayout
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.BackHandler
+import androidx.activity.compose.setContent
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.RepeatMode
+import androidx.compose.animation.core.animateFloat
+import androidx.compose.animation.core.infiniteRepeatable
+import androidx.compose.animation.core.rememberInfiniteTransition
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.Canvas
+import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.Button
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.Stroke
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.viewinterop.AndroidView
+import androidx.core.content.ContextCompat
+import com.airbnb.lottie.compose.LottieAnimation
+import com.airbnb.lottie.compose.LottieCompositionSpec
+import com.airbnb.lottie.compose.LottieConstants
+import com.airbnb.lottie.compose.animateLottieCompositionAsState
+import com.airbnb.lottie.compose.rememberLottieComposition
+import kotlin.math.PI
+import kotlin.math.cos
+import kotlin.math.min
+import kotlin.math.roundToInt
+import kotlin.math.sin
+
+class ReplayAnimationsActivity : ComponentActivity() {
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    setContent {
+      val primaryColor = Color(ContextCompat.getColor(this, R.color.colorPrimary))
+      val accentColor = Color(ContextCompat.getColor(this, R.color.colorAccent))
+      val colorScheme =
+        if (isSystemInDarkTheme())
+          darkColorScheme(primary = primaryColor, secondary = accentColor, tertiary = primaryColor)
+        else
+          lightColorScheme(primary = primaryColor, secondary = accentColor, tertiary = primaryColor)
+
+      MaterialTheme(colorScheme = colorScheme) { ReplayAnimationsScreen(onClose = { finish() }) }
+    }
+  }
+}
+
+@Composable
+private fun ReplayAnimationsScreen(onClose: () -> Unit) {
+  var selectedSample by remember { mutableStateOf<ReplayAnimationSample?>(null) }
+
+  BackHandler(enabled = selectedSample != null) { selectedSample = null }
+
+  selectedSample?.let { sample ->
+    ReplayAnimationDetailScreen(sample = sample, onBack = { selectedSample = null })
+    return
+  }
+
+  Column(
+    modifier =
+      Modifier.fillMaxSize()
+        .verticalScroll(rememberScrollState())
+        .padding(horizontal = 16.dp, vertical = 20.dp),
+    verticalArrangement = Arrangement.spacedBy(16.dp),
+  ) {
+    Button(onClick = onClose, modifier = Modifier.align(Alignment.End)) { Text("Close") }
+    Text(
+      text = "Replay animations",
+      style = MaterialTheme.typography.headlineSmall,
+      fontWeight = FontWeight.SemiBold,
+    )
+    ReplayAnimationSample.entries.forEach { sample ->
+      Button(onClick = { selectedSample = sample }, modifier = Modifier.fillMaxWidth()) {
+        Text(sample.title)
+      }
+    }
+  }
+}
+
+@Composable
+private fun ReplayAnimationDetailScreen(sample: ReplayAnimationSample, onBack: () -> Unit) {
+  Column(
+    modifier =
+      Modifier.fillMaxSize()
+        .verticalScroll(rememberScrollState())
+        .padding(horizontal = 16.dp, vertical = 20.dp),
+    verticalArrangement = Arrangement.spacedBy(16.dp),
+  ) {
+    Button(onClick = onBack, modifier = Modifier.align(Alignment.End)) { Text("Back") }
+    Text(
+      text = sample.title,
+      style = MaterialTheme.typography.headlineSmall,
+      fontWeight = FontWeight.SemiBold,
+    )
+    Surface(
+      modifier = Modifier.fillMaxWidth().height(420.dp),
+      shape = RoundedCornerShape(8.dp),
+      tonalElevation = 2.dp,
+      color = MaterialTheme.colorScheme.surfaceVariant,
+    ) {
+      Box(modifier = Modifier.fillMaxSize().padding(16.dp), contentAlignment = Alignment.Center) {
+        when (sample) {
+          ReplayAnimationSample.LOTTIE -> LottieReplayAnimation()
+          ReplayAnimationSample.COMPOSE_CANVAS -> ComposeCanvasAnimation()
+          ReplayAnimationSample.ANDROID_VIEWS ->
+            AndroidView(
+              factory = { context -> ClassicAnimationLayout(context) },
+              modifier = Modifier.fillMaxWidth().height(360.dp),
+            )
+        }
+      }
+    }
+  }
+}
+
+private enum class ReplayAnimationSample(val title: String) {
+  LOTTIE("Lottie"),
+  COMPOSE_CANVAS("Compose canvas"),
+  ANDROID_VIEWS("Android views"),
+}
+
+@Composable
+private fun LottieReplayAnimation() {
+  val composition by
+    rememberLottieComposition(LottieCompositionSpec.RawRes(R.raw.replay_lottie_pulse))
+  val progress by
+    animateLottieCompositionAsState(
+      composition = composition,
+      iterations = LottieConstants.IterateForever,
+    )
+
+  LottieAnimation(
+    composition = composition,
+    progress = { progress },
+    modifier = Modifier.fillMaxSize(),
+  )
+}
+
+@Composable
+private fun ComposeCanvasAnimation() {
+  val transition = rememberInfiniteTransition()
+  val angle by
+    transition.animateFloat(
+      initialValue = 0f,
+      targetValue = 360f,
+      animationSpec =
+        infiniteRepeatable(
+          animation = tween(1600, easing = LinearEasing),
+          repeatMode = RepeatMode.Restart,
+        ),
+    )
+  val pulse by
+    transition.animateFloat(
+      initialValue = 0.25f,
+      targetValue = 1f,
+      animationSpec =
+        infiniteRepeatable(
+          animation = tween(900, easing = LinearEasing),
+          repeatMode = RepeatMode.Reverse,
+        ),
+    )
+
+  Canvas(
+    modifier =
+      Modifier.fillMaxWidth().height(160.dp).background(Color(0xFF101820), RoundedCornerShape(8.dp))
+  ) {
+    val center = Offset(size.width / 2f, size.height / 2f)
+    val orbitRadius = min(size.width, size.height) * 0.32f
+    val ballRadius = min(size.width, size.height) * 0.1f
+    val radians = angle / 180f * PI.toFloat()
+
+    drawCircle(
+      color = Color(0xFF8BE9FD),
+      radius = orbitRadius * pulse,
+      center = center,
+      style = Stroke(width = 5.dp.toPx()),
+      alpha = 0.55f,
+    )
+    drawCircle(
+      color = Color(0xFFFF6B6B),
+      radius = ballRadius,
+      center = Offset(center.x + cos(radians) * orbitRadius, center.y + sin(radians) * orbitRadius),
+    )
+    drawCircle(
+      color = Color(0xFFFFD166),
+      radius = ballRadius * 0.75f,
+      center =
+        Offset(
+          center.x + cos(radians + PI.toFloat()) * orbitRadius,
+          center.y + sin(radians + PI.toFloat()) * orbitRadius,
+        ),
+    )
+  }
+}
+
+private class ClassicAnimationLayout(context: Context) : FrameLayout(context) {
+  private val movingDot =
+    View(context).apply { background = ovalDrawable(AndroidColor.rgb(255, 107, 107)) }
+  private val rotatingSquare =
+    View(context).apply { background = roundedRectDrawable(AndroidColor.rgb(139, 233, 253), dp(8)) }
+  private val scalingBar =
+    View(context).apply { background = roundedRectDrawable(AndroidColor.rgb(255, 209, 102), dp(6)) }
+  private val animators: List<Animator>
+
+  init {
+    setBackgroundColor(AndroidColor.rgb(16, 24, 32))
+    clipChildren = false
+    clipToPadding = false
+
+    addView(scalingBar, LayoutParams(dp(180), dp(18), Gravity.CENTER).apply { topMargin = dp(116) })
+    addView(rotatingSquare, LayoutParams(dp(64), dp(64), Gravity.CENTER))
+    addView(movingDot, LayoutParams(dp(48), dp(48), Gravity.CENTER))
+
+    animators =
+      listOf(
+        ObjectAnimator.ofFloat(movingDot, View.TRANSLATION_X, -dp(92).toFloat(), dp(92).toFloat())
+          .repeatable(durationMillis = 900, mode = ValueAnimator.REVERSE),
+        ObjectAnimator.ofFloat(movingDot, View.TRANSLATION_Y, -dp(28).toFloat(), dp(28).toFloat())
+          .repeatable(durationMillis = 650, mode = ValueAnimator.REVERSE),
+        ObjectAnimator.ofFloat(rotatingSquare, View.ROTATION, 0f, 360f)
+          .repeatable(durationMillis = 1200),
+        ObjectAnimator.ofFloat(scalingBar, View.SCALE_X, 0.25f, 1f)
+          .repeatable(durationMillis = 800, mode = ValueAnimator.REVERSE),
+      )
+  }
+
+  override fun onAttachedToWindow() {
+    super.onAttachedToWindow()
+    animators.forEach { animator ->
+      if (!animator.isStarted) {
+        animator.start()
+      }
+    }
+  }
+
+  override fun onDetachedFromWindow() {
+    animators.forEach { it.cancel() }
+    super.onDetachedFromWindow()
+  }
+
+  private fun ObjectAnimator.repeatable(
+    durationMillis: Long,
+    mode: Int = ValueAnimator.RESTART,
+  ): ObjectAnimator = apply {
+    duration = durationMillis
+    interpolator = LinearInterpolator()
+    repeatCount = ValueAnimator.INFINITE
+    repeatMode = mode
+  }
+
+  private fun dp(value: Int): Int = (value * resources.displayMetrics.density).roundToInt()
+
+  private fun ovalDrawable(color: Int): GradientDrawable =
+    GradientDrawable().apply {
+      shape = GradientDrawable.OVAL
+      setColor(color)
+    }
+
+  private fun roundedRectDrawable(color: Int, radius: Int): GradientDrawable =
+    GradientDrawable().apply {
+      shape = GradientDrawable.RECTANGLE
+      cornerRadius = radius.toFloat()
+      setColor(color)
+    }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/res/raw/replay_lottie_pulse.json b/sentry-samples/sentry-samples-android/src/main/res/raw/replay_lottie_pulse.json
new file mode 100644
index 00000000000..e09afc9c5e5
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/res/raw/replay_lottie_pulse.json
@@ -0,0 +1,181 @@
+{
+  "v": "5.7.4",
+  "fr": 60,
+  "ip": 0,
+  "op": 120,
+  "w": 256,
+  "h": 256,
+  "nm": "Replay pulse",
+  "ddd": 0,
+  "assets": [],
+  "layers": [
+    {
+      "ddd": 0,
+      "ind": 1,
+      "ty": 4,
+      "nm": "Rotating ring",
+      "sr": 1,
+      "ks": {
+        "o": { "a": 0, "k": 100 },
+        "r": {
+          "a": 1,
+          "k": [
+            {
+              "t": 0,
+              "s": [0],
+              "e": [360],
+              "i": { "x": [0.667], "y": [1] },
+              "o": { "x": [0.333], "y": [0] }
+            },
+            { "t": 120, "s": [360] }
+          ]
+        },
+        "p": { "a": 0, "k": [128, 128, 0] },
+        "a": { "a": 0, "k": [0, 0, 0] },
+        "s": { "a": 0, "k": [100, 100, 100] }
+      },
+      "ao": 0,
+      "shapes": [
+        {
+          "ty": "gr",
+          "it": [
+            {
+              "ty": "el",
+              "p": { "a": 0, "k": [0, 0] },
+              "s": { "a": 0, "k": [132, 132] },
+              "nm": "Ring path"
+            },
+            {
+              "ty": "tm",
+              "s": { "a": 0, "k": 18 },
+              "e": { "a": 0, "k": 86 },
+              "o": { "a": 0, "k": 0 },
+              "m": 1,
+              "nm": "Trim ring"
+            },
+            {
+              "ty": "st",
+              "c": { "a": 0, "k": [0.545, 0.914, 0.992, 1] },
+              "o": { "a": 0, "k": 100 },
+              "w": { "a": 0, "k": 16 },
+              "lc": 2,
+              "lj": 2,
+              "nm": "Ring stroke"
+            },
+            {
+              "ty": "tr",
+              "p": { "a": 0, "k": [0, 0] },
+              "a": { "a": 0, "k": [0, 0] },
+              "s": { "a": 0, "k": [100, 100] },
+              "r": { "a": 0, "k": 0 },
+              "o": { "a": 0, "k": 100 },
+              "sk": { "a": 0, "k": 0 },
+              "sa": { "a": 0, "k": 0 },
+              "nm": "Ring transform"
+            }
+          ],
+          "nm": "Ring",
+          "np": 4,
+          "cix": 2,
+          "bm": 0
+        }
+      ],
+      "ip": 0,
+      "op": 120,
+      "st": 0,
+      "bm": 0
+    },
+    {
+      "ddd": 0,
+      "ind": 2,
+      "ty": 4,
+      "nm": "Pulse",
+      "sr": 1,
+      "ks": {
+        "o": {
+          "a": 1,
+          "k": [
+            {
+              "t": 0,
+              "s": [35],
+              "e": [95],
+              "i": { "x": [0.667], "y": [1] },
+              "o": { "x": [0.333], "y": [0] }
+            },
+            {
+              "t": 60,
+              "s": [95],
+              "e": [35],
+              "i": { "x": [0.667], "y": [1] },
+              "o": { "x": [0.333], "y": [0] }
+            },
+            { "t": 120, "s": [35] }
+          ]
+        },
+        "r": { "a": 0, "k": 0 },
+        "p": { "a": 0, "k": [128, 128, 0] },
+        "a": { "a": 0, "k": [0, 0, 0] },
+        "s": {
+          "a": 1,
+          "k": [
+            {
+              "t": 0,
+              "s": [70, 70, 100],
+              "e": [115, 115, 100],
+              "i": { "x": [0.667], "y": [1] },
+              "o": { "x": [0.333], "y": [0] }
+            },
+            {
+              "t": 60,
+              "s": [115, 115, 100],
+              "e": [70, 70, 100],
+              "i": { "x": [0.667], "y": [1] },
+              "o": { "x": [0.333], "y": [0] }
+            },
+            { "t": 120, "s": [70, 70, 100] }
+          ]
+        }
+      },
+      "ao": 0,
+      "shapes": [
+        {
+          "ty": "gr",
+          "it": [
+            {
+              "ty": "el",
+              "p": { "a": 0, "k": [0, 0] },
+              "s": { "a": 0, "k": [96, 96] },
+              "nm": "Pulse path"
+            },
+            {
+              "ty": "fl",
+              "c": { "a": 0, "k": [1, 0.82, 0.4, 1] },
+              "o": { "a": 0, "k": 100 },
+              "r": 1,
+              "nm": "Pulse fill"
+            },
+            {
+              "ty": "tr",
+              "p": { "a": 0, "k": [0, 0] },
+              "a": { "a": 0, "k": [0, 0] },
+              "s": { "a": 0, "k": [100, 100] },
+              "r": { "a": 0, "k": 0 },
+              "o": { "a": 0, "k": 100 },
+              "sk": { "a": 0, "k": 0 },
+              "sa": { "a": 0, "k": 0 },
+              "nm": "Pulse transform"
+            }
+          ],
+          "nm": "Pulse",
+          "np": 3,
+          "cix": 2,
+          "bm": 0
+        }
+      ],
+      "ip": 0,
+      "op": 120,
+      "st": 0,
+      "bm": 0
+    }
+  ]
+}

From caa40f2853580011b123daf1c4485914716519b2 Mon Sep 17 00:00:00 2001
From: romtsn <4999776+romtsn@users.noreply.github.com>
Date: Wed, 3 Jun 2026 20:48:54 +0000
Subject: [PATCH 180/391] release: 8.43.1

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 71bf01b7bf0..d6a3b55b403 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.43.1
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index 9739db8a573..eee4b292bff 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.43.0
+versionName=8.43.1
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From d128fe99a5714c92b776f221d8e2778c9cf562a2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 4 Jun 2026 15:40:47 +0200
Subject: [PATCH 181/391] chore(deps): bump the github-actions group across 1
 directory with 7 updates (#5494)

Bumps the github-actions group with 7 updates in the / directory:

| Package | From | To |
| --- | --- | --- |
| [actions/checkout](https://github.com/actions/checkout) | `6.0.2` | `6.0.3` |
| [codecov/codecov-action](https://github.com/codecov/codecov-action) | `6.0.0` | `6.0.1` |
| [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) | `2.26.3` | `2.26.6` |
| [github/codeql-action](https://github.com/github/codeql-action) | `4.35.4` | `4.36.1` |
| [getsentry/github-workflows](https://github.com/getsentry/github-workflows) | `3.3.0` | `3.4.0` |
| [actions/create-github-app-token](https://github.com/actions/create-github-app-token) | `3.1.1` | `3.2.0` |
| [getsentry/craft](https://github.com/getsentry/craft) | `2.26.3` | `2.26.6` |



Updates `actions/checkout` from 6.0.2 to 6.0.3
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/de0fac2e4500dabe0009e67214ff5f5447ce83dd...df4cb1c069e1874edd31b4311f1884172cec0e10)

Updates `codecov/codecov-action` from 6.0.0 to 6.0.1
- [Release notes](https://github.com/codecov/codecov-action/releases)
- [Changelog](https://github.com/codecov/codecov-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/codecov/codecov-action/compare/57e3a136b779b570ffcdbf80b3bdc90e7fab3de2...e79a6962e0d4c0c17b229090214935d2e33f8354)

Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.26.3 to 2.26.6
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/bae212ca7aec50bb716eafd387c80bcfb28da937...3e6a0f477702864bb5854384b390a0db3325428e)

Updates `github/codeql-action` from 4.35.4 to 4.36.1
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/68bde559dea0fdcac2102bfdf6230c5f70eb485e...87557b9c84dde89fdd9b10e88954ac2f4248e463)

Updates `getsentry/github-workflows` from 3.3.0 to 3.4.0
- [Release notes](https://github.com/getsentry/github-workflows/releases)
- [Commits](https://github.com/getsentry/github-workflows/compare/3.3.0...3.4.0)

Updates `actions/create-github-app-token` from 3.1.1 to 3.2.0
- [Release notes](https://github.com/actions/create-github-app-token/releases)
- [Changelog](https://github.com/actions/create-github-app-token/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/create-github-app-token/compare/1b10c78c7865c340bc4f6099eb2f838309f1e8c3...bcd2ba49218906704ab6c1aa796996da409d3eb1)

Updates `getsentry/craft` from 2.26.3 to 2.26.6
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/bae212ca7aec50bb716eafd387c80bcfb28da937...3e6a0f477702864bb5854384b390a0db3325428e)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: 6.0.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: codecov/codecov-action
  dependency-version: 6.0.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.26.6
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action
  dependency-version: 4.36.1
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: getsentry/github-workflows
  dependency-version: 3.4.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: actions/create-github-app-token
  dependency-version: 3.2.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: getsentry/craft
  dependency-version: 2.26.6
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 4 ++--
 .github/workflows/changelog-preview.yml             | 2 +-
 .github/workflows/changes-in-high-risk-code.yml     | 2 +-
 .github/workflows/check-tombstone-proto-schema.yml  | 2 +-
 .github/workflows/codeql-analysis.yml               | 6 +++---
 .github/workflows/danger.yml                        | 2 +-
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 4 ++--
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/release.yml                       | 6 +++---
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 .github/workflows/update-deps.yml                   | 2 +-
 .github/workflows/validate-pr.yml                   | 2 +-
 22 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index f3ad7240438..aebcbf87d5e 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -28,7 +28,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6817ce53337..2d9e2a3ba38 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -19,7 +19,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           ref: ${{ github.event.pull_request.head.sha || github.sha }}
           submodules: 'recursive'
@@ -58,7 +58,7 @@ jobs:
           SENTRY_PROJECT: sentry-android
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@57e3a136b779b570ffcdbf80b3bdc90e7fab3de2 # pin@v4
+        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # pin@v4
         with:
           name: sentry-java
           fail_ci_if_error: false
diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index 4d5a78a4114..23daafa1a05 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@bae212ca7aec50bb716eafd387c80bcfb28da937 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@3e6a0f477702864bb5854384b390a0db3325428e # v2
     secrets: inherit
diff --git a/.github/workflows/changes-in-high-risk-code.yml b/.github/workflows/changes-in-high-risk-code.yml
index 4ecc23619a4..028b4217ef2 100644
--- a/.github/workflows/changes-in-high-risk-code.yml
+++ b/.github/workflows/changes-in-high-risk-code.yml
@@ -16,7 +16,7 @@ jobs:
       high_risk_code: ${{ steps.changes.outputs.high_risk_code }}
       high_risk_code_files: ${{ steps.changes.outputs.high_risk_code_files }}
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
       - name: Get changed files
         id: changes
         uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
diff --git a/.github/workflows/check-tombstone-proto-schema.yml b/.github/workflows/check-tombstone-proto-schema.yml
index f4dd5f2f957..535b2170fae 100644
--- a/.github/workflows/check-tombstone-proto-schema.yml
+++ b/.github/workflows/check-tombstone-proto-schema.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
 
       - name: Check for newer Tombstone proto schema
         run: ./scripts/check-tombstone-proto-schema.sh
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 34bf6241fd6..1276f2bd715 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@68bde559dea0fdcac2102bfdf6230c5f70eb485e # pin@v2
+        uses: github/codeql-action/init@87557b9c84dde89fdd9b10e88954ac2f4248e463 # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@68bde559dea0fdcac2102bfdf6230c5f70eb485e # pin@v2
+        uses: github/codeql-action/analyze@87557b9c84dde89fdd9b10e88954ac2f4248e463 # pin@v2
diff --git a/.github/workflows/danger.yml b/.github/workflows/danger.yml
index 77fe824701a..e40b4563b00 100644
--- a/.github/workflows/danger.yml
+++ b/.github/workflows/danger.yml
@@ -8,4 +8,4 @@ jobs:
   danger:
     runs-on: ubuntu-latest
     steps:
-      - uses: getsentry/github-workflows/danger@26f565c05d0dd49f703d238706b775883037d76b # v3
+      - uses: getsentry/github-workflows/danger@607fed74f812e69201531a5185b6c3c57caa4e89 # v3
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index 23dd0134203..01ee3db1584 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -20,7 +20,7 @@ jobs:
           java-version: '17'
 
       - name: Checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
 
       # TODO: remove this when upstream is fixed
       - name: Disable Gradle configuration cache (see https://github.com/fossas/fossa-cli/issues/872)
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index 4109c2a2947..28cb78df4e3 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index 090a6360745..af0b44ddadd 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout 🛎️
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index bbe8c709587..65cfcf242fc 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -27,7 +27,7 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
@@ -77,7 +77,7 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index 6d0aefab386..19598699165 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
 
       - name: Setup Java Version
         uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 85731127f36..8973148cadd 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -27,7 +27,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
 
       - name: Set up Java 17
         uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
@@ -77,7 +77,7 @@ jobs:
             arch: x86_64
     steps:
       - name: Checkout code
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
 
       - name: Enable KVM
         run: |
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index fbb8018da06..4af564cd2c3 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -22,7 +22,7 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 3fb0b162750..16cfe4531a0 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -15,7 +15,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 8464e8d0399..88cac7c6754 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -23,18 +23,18 @@ jobs:
     steps:
       - name: Get auth token
         id: token
-        uses: actions/create-github-app-token@1b10c78c7865c340bc4f6099eb2f838309f1e8c3 # v3.1.1
+        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1 # v3.2.0
         with:
           app-id: ${{ vars.SENTRY_RELEASE_BOT_CLIENT_ID }}
           private-key: ${{ secrets.SENTRY_RELEASE_BOT_PRIVATE_KEY }}
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           token: ${{ steps.token.outputs.token }}
           # Needs to be set, otherwise git describe --tags will fail with: No names found, cannot describe anything
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@bae212ca7aec50bb716eafd387c80bcfb28da937 # v2
+        uses: getsentry/craft@3e6a0f477702864bb5854384b390a0db3325428e # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 91154a2c7b3..bbcb3cfc0bc 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index f0b3fbe279b..781d8a876f9 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 68bdd38f2ec..bc1b1686692 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index fc66f6744b5..b1884cd4a7a 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -98,7 +98,7 @@ jobs:
             agent: "false"
             agent-auto-init: "true"
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/update-deps.yml b/.github/workflows/update-deps.yml
index bfcf9ccfa85..5b8d3d11628 100644
--- a/.github/workflows/update-deps.yml
+++ b/.github/workflows/update-deps.yml
@@ -18,7 +18,7 @@ jobs:
   native:
     runs-on: ubuntu-latest
     steps:
-      - uses: getsentry/github-workflows/updater@26f565c05d0dd49f703d238706b775883037d76b # v3
+      - uses: getsentry/github-workflows/updater@607fed74f812e69201531a5185b6c3c57caa4e89 # v3
         with:
           path: scripts/update-sentry-native-ndk.sh
           name: Native SDK
diff --git a/.github/workflows/validate-pr.yml b/.github/workflows/validate-pr.yml
index 10fe894067a..313a4611145 100644
--- a/.github/workflows/validate-pr.yml
+++ b/.github/workflows/validate-pr.yml
@@ -10,7 +10,7 @@ jobs:
     permissions:
       pull-requests: write
     steps:
-      - uses: getsentry/github-workflows/validate-pr@71588ddf95134f804e82c5970a8098588e2eaecd
+      - uses: getsentry/github-workflows/validate-pr@26f565c05d0dd49f703d238706b775883037d76b
         with:
           app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
           private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}

From 65aff4f61d87bda0ca21a6093854008c39377946 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 4 Jun 2026 16:44:03 +0200
Subject: [PATCH 182/391] ci: Update getsentry/github-workflows to 3.4.0 for
 validate-pr (#5496)

The validate-pr action was pinned to 3.3.0 while the other workflows
in this repo already use 3.4.0. Pin it to the same SHA and add the
matching version comment.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .github/workflows/validate-pr.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/validate-pr.yml b/.github/workflows/validate-pr.yml
index 313a4611145..ca5108943de 100644
--- a/.github/workflows/validate-pr.yml
+++ b/.github/workflows/validate-pr.yml
@@ -10,7 +10,7 @@ jobs:
     permissions:
       pull-requests: write
     steps:
-      - uses: getsentry/github-workflows/validate-pr@26f565c05d0dd49f703d238706b775883037d76b
+      - uses: getsentry/github-workflows/validate-pr@607fed74f812e69201531a5185b6c3c57caa4e89 # v3
         with:
           app-id: ${{ vars.SDK_MAINTAINER_BOT_APP_ID }}
           private-key: ${{ secrets.SDK_MAINTAINER_BOT_PRIVATE_KEY }}

From b93642593067222cc2b5a8ab4f9a63a38cde8ae3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 5 Jun 2026 10:04:18 +0200
Subject: [PATCH 183/391] chore(deps): bump the github-actions group with 3
 updates (#5498)

Bumps the github-actions group with 3 updates: [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft), [github/codeql-action](https://github.com/github/codeql-action) and [getsentry/craft](https://github.com/getsentry/craft).


Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.26.6 to 2.26.8
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/3e6a0f477702864bb5854384b390a0db3325428e...4468eb9e399655a61c770534dacc03139d98aa18)

Updates `github/codeql-action` from 4.36.1 to 4.36.2
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/87557b9c84dde89fdd9b10e88954ac2f4248e463...8aad20d150bbac5944a9f9d289da16a4b0d87c1e)

Updates `getsentry/craft` from 2.26.6 to 2.26.8
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/3e6a0f477702864bb5854384b390a0db3325428e...4468eb9e399655a61c770534dacc03139d98aa18)

---
updated-dependencies:
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.26.8
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action
  dependency-version: 4.36.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: getsentry/craft
  dependency-version: 2.26.8
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/changelog-preview.yml | 2 +-
 .github/workflows/codeql-analysis.yml   | 4 ++--
 .github/workflows/release.yml           | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index 23daafa1a05..612cc5b52f3 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@3e6a0f477702864bb5854384b390a0db3325428e # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@4468eb9e399655a61c770534dacc03139d98aa18 # v2
     secrets: inherit
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 1276f2bd715..6aa197d6625 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@87557b9c84dde89fdd9b10e88954ac2f4248e463 # pin@v2
+        uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@87557b9c84dde89fdd9b10e88954ac2f4248e463 # pin@v2
+        uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # pin@v2
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 88cac7c6754..a6964cec4ba 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@3e6a0f477702864bb5854384b390a0db3325428e # v2
+        uses: getsentry/craft@4468eb9e399655a61c770534dacc03139d98aa18 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From abcd8895429bce96de12618799bf303bb34d2312 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Mon, 8 Jun 2026 17:37:59 +0200
Subject: [PATCH 184/391] fix(replay): Fix Compose masking on
 obfuscated/minified builds (#5503)

* try to run replay tests on gh emulators

* Format code

* feat(replay): fail fast on swallowed Compose masking errors in CI

Add an internal SentryReplayDebug.failFast switch (gated on the
io.sentry.replay.compose.fail-fast system property) that re-throws the
exceptions ComposeViewHierarchyNode normally swallows in fromComposeNode
and fromView. Enabled in the sentry-samples-android app and the on-device
ReplayTest/ReplaySnapshotTest so our release/obfuscated builds running on
real devices in CI crash instead of silently degrading masking. Defaults
off, so customers are unaffected.

Also add consumer proguard keep rules for the LayoutNode internals
(getChildren/getOuterCoordinator/getCollapsedSemantics) that are looked up
via reflection on Compose < 1.10, so R8 doesn't strip or rename them.

Also guard the on-device tests against GitHub-hosted emulators, which
can't capture screenshots reliably.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  6 +++++
 .../io/sentry/uitest/android/ReplayTest.kt    |  3 +++
 .../uitest/android/ReplaySnapshotTest.kt      |  3 +++
 sentry-android-replay/proguard-rules.pro      |  6 +++++
 .../android/replay/util/SentryReplayDebug.kt  | 26 +++++++++++++++++++
 .../viewhierarchy/ComposeViewHierarchyNode.kt | 12 +++++++++
 .../sentry/samples/android/MyApplication.java |  5 ++++
 7 files changed, 61 insertions(+)
 create mode 100644 sentry-android-replay/src/main/java/io/sentry/android/replay/util/SentryReplayDebug.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d6a3b55b403..06c0b8bab55 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Session Replay: Fix Compose view masking not working on obfuscated/minified builds ([#5503](https://github.com/getsentry/sentry-java/pull/5503))
+
 ## 8.43.1
 
 ### Fixes
diff --git a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt
index 5ea12ddbbc8..3827561e37c 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt
@@ -21,6 +21,9 @@ class ReplayTest : BaseUiTest() {
     // we can't run on GH actions emulator, because they don't allow capturing screenshots properly
     @Suppress("KotlinConstantConditions")
     assumeThat(BuildConfig.ENVIRONMENT != "github", `is`(true))
+    // crash on swallowed Compose masking errors (e.g. broken obfuscated internals) so regressions
+    // fail this on-device test instead of silently under-masking (see SentryReplayDebug)
+    System.setProperty("io.sentry.replay.compose.fail-fast", "true")
   }
 
   @Test
diff --git a/sentry-android-integration-tests/sentry-uitest-android/src/androidTestReplay/java/io/sentry/uitest/android/ReplaySnapshotTest.kt b/sentry-android-integration-tests/sentry-uitest-android/src/androidTestReplay/java/io/sentry/uitest/android/ReplaySnapshotTest.kt
index 1d82a3f8bc0..6d45b2d1f9c 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/src/androidTestReplay/java/io/sentry/uitest/android/ReplaySnapshotTest.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android/src/androidTestReplay/java/io/sentry/uitest/android/ReplaySnapshotTest.kt
@@ -23,6 +23,9 @@ class ReplaySnapshotTest : BaseUiTest() {
     // GH Actions emulators don't support capturing screenshots for replay
     @Suppress("KotlinConstantConditions")
     assumeThat(BuildConfig.ENVIRONMENT != "github", `is`(true))
+    // crash on swallowed Compose masking errors (e.g. broken obfuscated internals) so regressions
+    // fail this on-device test instead of silently under-masking (see SentryReplayDebug)
+    System.setProperty("io.sentry.replay.compose.fail-fast", "true")
   }
 
   @Test
diff --git a/sentry-android-replay/proguard-rules.pro b/sentry-android-replay/proguard-rules.pro
index 42e3cb30a42..6ce45c1ef5d 100644
--- a/sentry-android-replay/proguard-rules.pro
+++ b/sentry-android-replay/proguard-rules.pro
@@ -29,3 +29,9 @@
 # Rules to detect a PreviewView view to later mask it
 -dontwarn androidx.camera.view.PreviewView
 -keepnames class androidx.camera.view.PreviewView
+# Rules to walk the Compose Node tree.
+-keep class androidx.compose.ui.node.LayoutNode {
+    *** getChildren*(...);
+    *** getOuterCoordinator*(...);
+    *** getCollapsedSemantics*(...);
+}
\ No newline at end of file
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/SentryReplayDebug.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/SentryReplayDebug.kt
new file mode 100644
index 00000000000..966428f84c2
--- /dev/null
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/SentryReplayDebug.kt
@@ -0,0 +1,26 @@
+package io.sentry.android.replay.util
+
+/**
+ * Internal, undocumented escape hatch used to make Session Replay fail fast instead of silently
+ * degrading masking when an exception is swallowed (e.g. unsupported/obfuscated Compose internals).
+ *
+ * It is intended to be enabled only in our own sample/UI-test apps that run on real devices in CI
+ * (which are release/obfuscated builds, so [io.sentry.android.replay.BuildConfig.DEBUG] can't be
+ * used), so that regressions surface as crashes rather than under-masked replays. Customers should
+ * never set this.
+ *
+ * Enable via:
+ * ```
+ * System.setProperty("io.sentry.replay.compose.fail-fast", "true")
+ * ```
+ */
+internal object SentryReplayDebug {
+  private const val FAIL_FAST_PROPERTY = "io.sentry.replay.compose.fail-fast"
+
+  /**
+   * Read live (not cached) so it's only evaluated on the error path and unit tests can toggle it
+   * between cases.
+   */
+  val failFast: Boolean
+    get() = "true".equals(System.getProperty(FAIL_FAST_PROPERTY), ignoreCase = true)
+}
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
index a0312b69cd0..2b6bc3fc08e 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
@@ -22,6 +22,7 @@ import io.sentry.SentryLevel
 import io.sentry.SentryMaskingOptions
 import io.sentry.android.replay.SentryReplayModifiers
 import io.sentry.android.replay.util.ComposeTextLayout
+import io.sentry.android.replay.util.SentryReplayDebug
 import io.sentry.android.replay.util.boundsInWindow
 import io.sentry.android.replay.util.findPainter
 import io.sentry.android.replay.util.findTextColor
@@ -147,6 +148,12 @@ internal object ComposeViewHierarchyNode {
         )
       }
 
+      // fail fast in our own sample/UI-test apps (see SentryReplayDebug), so regressions surface
+      // as crashes instead of silently degrading masking
+      if (SentryReplayDebug.failFast) {
+        throw t
+      }
+
       // If we're unable to retrieve the semantics configuration
       // we should play safe and mask the whole node.
       return GenericViewHierarchyNode(
@@ -291,6 +298,11 @@ internal object ComposeViewHierarchyNode {
         """
           .trimIndent(),
       )
+      // fail fast in our own sample/UI-test apps (see SentryReplayDebug), so regressions surface
+      // as crashes instead of silently skipping the whole Compose subtree (i.e. not masking it)
+      if (SentryReplayDebug.failFast) {
+        throw e
+      }
       return false
     }
 
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java
index 572c4cdba72..f074901f4f0 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java
@@ -9,6 +9,11 @@ public class MyApplication extends Application {
 
   @Override
   public void onCreate() {
+    // Make Session Replay fail fast instead of silently degrading masking when an exception is
+    // swallowed (e.g. unsupported/obfuscated Compose internals). This way regressions surface as
+    // crashes in our release/obfuscated builds that run on real devices in CI. Only meant for our
+    // own sample/UI-test apps, customers should never set this.
+    System.setProperty("io.sentry.replay.compose.fail-fast", "true");
     Sentry.startProfiler();
     strictMode();
     super.onCreate();

From 8c7718c4199deb7d801a643ba768d97f499ec156 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Mon, 8 Jun 2026 17:51:12 +0200
Subject: [PATCH 185/391] fix(replay): Fix VerifyError in Compose masking under
 DexGuard/R8 obfuscation (#5507)

* fix(replay): Fix VerifyError in Compose masking under DexGuard/R8 obfuscation

ComposeViewHierarchyNode.boundsInWindow returned an android.graphics.Rect
while the surrounding code carried it as androidx.compose.ui.geometry.Rect,
mixing the two Rect types in the same method. Under aggressive obfuscation
(DexGuard 9.13.2 / R8 full mode) this could be rejected at class load with
a VerifyError, crashing Replay when traversing the Compose tree.

Make boundsInWindow return androidx.compose.ui.geometry.Rect throughout and
add a Rect.toRect() extension to convert to android.graphics.Rect only at
the boundary where the view-hierarchy node needs it.

Fixes #5497

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* fix(replay): Round Compose mask bounds outward to avoid zero-area masks

isVisible/shouldMask are derived from the sub-pixel float bounds, but the
android.graphics.Rect stored on the node (and drawn by MaskRenderer) used
truncating toInt(). A sub-pixel node could be marked visible+maskable yet
store a zero-width/height rect, so the mask wasn't drawn and sensitive
content leaked. Round outward (floor min, ceil max) so a non-empty float
rect always yields a non-empty integer rect, biasing toward over-masking.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../io/sentry/android/replay/util/Nodes.kt    | 21 ++++++++++--
 .../viewhierarchy/ComposeViewHierarchyNode.kt | 33 ++++++++++---------
 3 files changed, 36 insertions(+), 19 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 06c0b8bab55..d80037414db 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Session Replay: Fix `VerifyError` in Compose masking under DexGuard/R8 obfuscation ([#5507](https://github.com/getsentry/sentry-java/pull/5507))
 - Session Replay: Fix Compose view masking not working on obfuscated/minified builds ([#5503](https://github.com/getsentry/sentry-java/pull/5503))
 
 ## 8.43.1
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
index 2882b2113b8..028f681d96b 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
@@ -2,8 +2,8 @@
 
 package io.sentry.android.replay.util
 
-import android.graphics.Rect
 import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.ColorProducer
 import androidx.compose.ui.graphics.painter.Painter
@@ -11,6 +11,8 @@ import androidx.compose.ui.layout.LayoutCoordinates
 import androidx.compose.ui.layout.findRootCoordinates
 import androidx.compose.ui.node.LayoutNode
 import androidx.compose.ui.text.TextLayoutResult
+import kotlin.math.ceil
+import kotlin.math.floor
 import kotlin.math.roundToInt
 
 internal class ComposeTextLayout(internal val layout: TextLayoutResult) : TextLayout {
@@ -176,7 +178,7 @@ internal fun LayoutCoordinates.boundsInWindow(rootCoordinates: LayoutCoordinates
   val boundsBottom = bounds.bottom.fastCoerceIn(0f, rootHeight)
 
   if (boundsLeft == boundsRight || boundsTop == boundsBottom) {
-    return Rect()
+    return Rect(0.0f, 0.0f, 0.0f, 0.0f)
   }
 
   val topLeft = root.localToWindow(Offset(boundsLeft, boundsTop))
@@ -200,5 +202,18 @@ internal fun LayoutCoordinates.boundsInWindow(rootCoordinates: LayoutCoordinates
   val top = fastMinOf(topLeftY, topRightY, bottomLeftY, bottomRightY)
   val bottom = fastMaxOf(topLeftY, topRightY, bottomLeftY, bottomRightY)
 
-  return Rect(left.toInt(), top.toInt(), right.toInt(), bottom.toInt())
+  return Rect(left, top, right, bottom)
+}
+
+internal fun Rect.toRect(): android.graphics.Rect {
+  // Round outward (floor min edges, ceil max edges) so that a sub-pixel but non-empty Rect doesn't
+  // collapse to a zero-width/height android.graphics.Rect. Otherwise a node could be marked visible
+  // and maskable based on the float bounds, while the integer rect the MaskRenderer draws has zero
+  // area, leaving sensitive content unmasked. Rounding outward also biases toward over-masking.
+  return android.graphics.Rect(
+    floor(left).toInt(),
+    floor(top).toInt(),
+    ceil(right).toInt(),
+    ceil(bottom).toInt(),
+  )
 }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
index 2b6bc3fc08e..2e40144e2de 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ComposeViewHierarchyNode.kt
@@ -28,6 +28,7 @@ import io.sentry.android.replay.util.findPainter
 import io.sentry.android.replay.util.findTextColor
 import io.sentry.android.replay.util.isMaskable
 import io.sentry.android.replay.util.toOpaque
+import io.sentry.android.replay.util.toRect
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.GenericViewHierarchyNode
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.ImageViewHierarchyNode
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.TextViewHierarchyNode
@@ -157,8 +158,8 @@ internal object ComposeViewHierarchyNode {
       // If we're unable to retrieve the semantics configuration
       // we should play safe and mask the whole node.
       return GenericViewHierarchyNode(
-        x = visibleRect.left.toFloat(),
-        y = visibleRect.top.toFloat(),
+        x = visibleRect.left,
+        y = visibleRect.top,
         width = node.width,
         height = node.height,
         elevation = (parent?.elevation ?: 0f),
@@ -168,17 +169,17 @@ internal object ComposeViewHierarchyNode {
         isImportantForContentCapture = false, // will be set by children
         isVisible =
           !SentryLayoutNodeHelper.isTransparent(node) &&
-            visibleRect.height() > 0 &&
-            visibleRect.width() > 0,
-        visibleRect = visibleRect,
+            visibleRect.height > 0 &&
+            visibleRect.width > 0,
+        visibleRect = visibleRect.toRect(),
       )
     }
 
     val isVisible =
       !SentryLayoutNodeHelper.isTransparent(node) &&
         (semantics == null || !semantics.contains(SemanticsProperties.InvisibleToUser)) &&
-        visibleRect.height() > 0 &&
-        visibleRect.width() > 0
+        visibleRect.height > 0 &&
+        visibleRect.width > 0
     val isEditable =
       semantics?.contains(SemanticsActions.SetText) == true ||
         semantics?.contains(SemanticsProperties.EditableText) == true
@@ -213,8 +214,8 @@ internal object ComposeViewHierarchyNode {
               null
             },
           dominantColor = textColor?.toArgb()?.toOpaque(),
-          x = visibleRect.left.toFloat(),
-          y = visibleRect.top.toFloat(),
+          x = visibleRect.left,
+          y = visibleRect.top,
           width = node.width,
           height = node.height,
           elevation = (parent?.elevation ?: 0f),
@@ -223,7 +224,7 @@ internal object ComposeViewHierarchyNode {
           shouldMask = shouldMask,
           isImportantForContentCapture = true,
           isVisible = isVisible,
-          visibleRect = visibleRect,
+          visibleRect = visibleRect.toRect(),
         )
       }
       else -> {
@@ -233,8 +234,8 @@ internal object ComposeViewHierarchyNode {
 
           parent?.setImportantForCaptureToAncestors(true)
           ImageViewHierarchyNode(
-            x = visibleRect.left.toFloat(),
-            y = visibleRect.top.toFloat(),
+            x = visibleRect.left,
+            y = visibleRect.top,
             width = node.width,
             height = node.height,
             elevation = (parent?.elevation ?: 0f),
@@ -243,7 +244,7 @@ internal object ComposeViewHierarchyNode {
             isVisible = isVisible,
             isImportantForContentCapture = true,
             shouldMask = shouldMask && painter.isMaskable(),
-            visibleRect = visibleRect,
+            visibleRect = visibleRect.toRect(),
           )
         } else {
           val shouldMask = isVisible && semantics.shouldMask(isImage = false, options)
@@ -252,8 +253,8 @@ internal object ComposeViewHierarchyNode {
           // TODO: traverse the ViewHierarchyNode here again. For now we can recommend
           // TODO: using custom modifiers to obscure the entire node if it's sensitive
           GenericViewHierarchyNode(
-            x = visibleRect.left.toFloat(),
-            y = visibleRect.top.toFloat(),
+            x = visibleRect.left,
+            y = visibleRect.top,
             width = node.width,
             height = node.height,
             elevation = (parent?.elevation ?: 0f),
@@ -262,7 +263,7 @@ internal object ComposeViewHierarchyNode {
             shouldMask = shouldMask,
             isImportantForContentCapture = false, // will be set by children
             isVisible = isVisible,
-            visibleRect = visibleRect,
+            visibleRect = visibleRect.toRect(),
           )
         }
       }

From 80199f8effacbd46531006e0c25645ef0c24d518 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 9 Jun 2026 09:13:40 +0200
Subject: [PATCH 186/391] docs(ai): Refresh AGENTS.md module list and fix
 coding.mdc command (#5517)

* docs(ai): Refresh AGENTS.md module list and fix coding.mdc command

The Module Architecture section omitted several product areas that now
exist as modules and already have dedicated .cursor/rules: Session
Replay, Feature Flags, Queues (Kafka), and JVM continuous profiling. Add
them alongside the other previously-unlisted modules, and add a pointer
to the repository's task-specific skills.

Also fix a typo in coding.mdc where the per-file test command used
./gradle instead of ./gradlew.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(ai): Note moving changelog entries to Unreleased on rebase

A rebase onto main can land a branch after a release was cut, leaving a
new changelog entry under an already-released version heading. Document
that the entry should be moved back into an Unreleased section at the
top of CHANGELOG.md.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(ai): Add changelog rebase note to AGENTS.md

AGENTS.md is the always-loaded entrypoint, so the rebase reminder reaches
agents more reliably here than in an on-demand .cursor rule. Keep the
detailed workflow in pr.mdc and point to it from here.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .cursor/rules/coding.mdc |  4 ++--
 .cursor/rules/pr.mdc     |  2 ++
 AGENTS.md                | 23 +++++++++++++++++++++--
 3 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/.cursor/rules/coding.mdc b/.cursor/rules/coding.mdc
index e7af7273f15..4e6fd2538a3 100644
--- a/.cursor/rules/coding.mdc
+++ b/.cursor/rules/coding.mdc
@@ -24,13 +24,13 @@ sentry-java is the Java and Android SDK for Sentry. This repository contains the
 ./gradlew check
 
 # Run unit tests for a specific file
-./gradle ':<module>:testDebugUnitTest' --tests="*<file name>*" --info
+./gradlew ':<module>:testDebugUnitTest' --tests="*<file name>*" --info
 ```
 
 ## Contributing Guidelines
 
 1. Follow existing code style and language
-2. Do not modify the API files (e.g. sentry.api) manually, instead run `./gradlew  apiDump` to regenerate them
+2. Do not modify the API files (e.g. sentry.api) manually, instead run `./gradlew apiDump` to regenerate them
 3. Write comprehensive tests
 4. New features should always be opt-in by default, extend `SentryOptions` or similar Option classes with getters and setters to enable/disable a new feature
 5. Consider backwards compatibility
diff --git a/.cursor/rules/pr.mdc b/.cursor/rules/pr.mdc
index e15c0a0a563..3a37ecc15f8 100644
--- a/.cursor/rules/pr.mdc
+++ b/.cursor/rules/pr.mdc
@@ -93,6 +93,8 @@ Entry format:
 - <Short description> ([#<PR_NUMBER>](https://github.com/getsentry/sentry-java/pull/<PR_NUMBER>))
 ```
 
+**When rebasing:** A rebase onto `main` can land your branch after a release was cut, where the `## Unreleased` heading your entry lived under has since been renamed to that version number. If that happens, move your new entry into an `## Unreleased` section at the top of `CHANGELOG.md` (create the section if it no longer exists) so it is not left under an already-released version.
+
 Commit changelog separately:
 
 ```bash
diff --git a/AGENTS.md b/AGENTS.md
index ff50727c662..8d0cccabbc7 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -92,6 +92,14 @@ make systemTest
 6. **Format and regenerate**: Once done, format code and regenerate .api files: `./gradlew spotlessApply apiDump`
 7. **Propose commit**: As final step, git stage relevant files and propose (but not execute) a single git commit command
 
+## Repository Skills
+
+This repo ships task-specific skills (declared in `agents.toml`, sources under `.agents/skills`). Prefer them over performing the steps manually:
+- **`create-java-pr`**: Branch, format, `apiDump`, commit, push, open PR, and add the changelog entry (automates the PR workflow above)
+- **`test`**: Run unit or system tests for a module or a specific class
+- **`check-code-attribution`**: Verify third-party code attribution on the current branch (see Third-Party Code Attribution below)
+- **`btrace-perfetto`**: Capture and compare Perfetto traces for Android performance work
+
 ## Module Architecture
 
 The repository is organized into multiple modules:
@@ -100,15 +108,22 @@ The repository is organized into multiple modules:
 - **`sentry`** - Core Java SDK implementation
 - **`sentry-android-core`** - Core Android SDK implementation
 - **`sentry-android`** - High-level Android SDK
+- **`sentry-android-ndk`** - Native (NDK) crash handling
 
 ### Integration Modules
 - **Spring Framework**: `sentry-spring*`, `sentry-spring-boot*`
-- **Logging**: `sentry-logback`, `sentry-log4j2`, `sentry-jul`
-- **Web**: `sentry-servlet*`, `sentry-okhttp`, `sentry-apache-http-client-5`
+- **Logging**: `sentry-logback`, `sentry-log4j2`, `sentry-jul`, `sentry-android-timber`
+- **Web**: `sentry-servlet*`, `sentry-okhttp`, `sentry-openfeign`, `sentry-apache-http-client-5`
 - **GraphQL**: `sentry-graphql*`, `sentry-apollo*`
 - **Android UI**: `sentry-android-fragment`, `sentry-android-navigation`, `sentry-compose`
+- **Session Replay**: `sentry-android-replay`
+- **Database**: `sentry-jdbc`, `sentry-android-sqlite`, `sentry-jcache`
 - **Reactive**: `sentry-reactor`, `sentry-ktor-client`
+- **Feature Flags**: `sentry-launchdarkly-android`, `sentry-launchdarkly-server`, `sentry-openfeature`
+- **Queues**: `sentry-kafka`
+- **Profiling**: `sentry-async-profiler` (JVM continuous profiling)
 - **Monitoring**: `sentry-opentelemetry*`, `sentry-quartz`
+- **Other**: `sentry-spotlight`, `sentry-kotlin-extensions`, `sentry-android-distribution`
 
 ### Utility Modules
 - **`sentry-test-support`** - Shared test utilities
@@ -171,6 +186,10 @@ gh pr view <branch-name> --json number -q '.number'
 gh pr view --json url -q '.url'
 ```
 
+### Changelog
+
+User-facing changes get an entry under the `## Unreleased` section of `CHANGELOG.md`. When rebasing onto `main`, a release may have renamed the `## Unreleased` heading your entry was under to a version number — if so, move your entry back into an `## Unreleased` section at the top of the file (create it if it no longer exists). See `.cursor/rules/pr.mdc` for the full changelog and PR workflow.
+
 ## Useful Resources
 
 - Main SDK documentation: https://develop.sentry.dev/sdk/overview/

From 105d667ed4ed37d897fe8e9199de23357896e550 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Tue, 9 Jun 2026 09:42:26 +0200
Subject: [PATCH 187/391] fix(license): Attribute vendored AndroidX Compose UI
 code in Session Replay (#5516)

sentry-android-replay's Nodes.kt vendors code from AndroidX Compose UI
(Apache 2.0, The Android Open Source Project) without attribution:
- boundsInWindow is a faster copy of LayoutCoordinates.boundsInWindow
- fastMinOf/fastMaxOf/fastCoerceIn/fastCoerceAtLeast/fastCoerceAtMost are
  copied from androidx.compose.ui.util.MathHelpers

Add the required source-file attribution header and a THIRD_PARTY_NOTICES.md
entry covering both source files.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 THIRD_PARTY_NOTICES.md                        | 29 +++++++++++++++++++
 .../io/sentry/android/replay/util/Nodes.kt    | 22 ++++++++++++++
 2 files changed, 51 insertions(+)

diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index 5a48d567fac..c1fa7e8f65b 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -315,6 +315,35 @@ limitations under the License.
 
 ---
 
+## Android Open Source Project — Jetpack Compose UI (Apache 2.0)
+
+**Source:** https://github.com/androidx/androidx/blob/fc7df0dd68466ac3bb16b1c79b7a73dd0bfdd4c1/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/layout/LayoutCoordinates.kt#L187<br>
+**Source:** https://github.com/androidx/androidx/blob/androidx-main/compose/ui/ui-util/src/commonMain/kotlin/androidx/compose/ui/util/MathHelpers.kt<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright (C) 2019, 2020 The Android Open Source Project
+
+### Scope
+
+The Sentry Android Replay SDK includes code adapted from Jetpack Compose UI, used to compute Compose node bounds while traversing the view hierarchy for masking. The code resides in `io.sentry.android.replay.util.Nodes`: the `boundsInWindow` extension function (a faster copy of `LayoutCoordinates.boundsInWindow`) and the `fastMinOf`, `fastMaxOf`, `fastCoerceIn`, `fastCoerceAtLeast`, and `fastCoerceAtMost` numeric helpers (copied from `androidx.compose.ui.util.MathHelpers`).
+
+```
+Copyright (C) 2019, 2020 The Android Open Source Project
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
 ## OpenTelemetry (Apache 2.0)
 
 **Source:** https://github.com/open-telemetry/opentelemetry-java (Commit: 0aacc55d1e3f5cc6dbb4f8fa26bcb657b01a7bc9)<br>
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
index 028f681d96b..704260cf311 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/Nodes.kt
@@ -1,3 +1,25 @@
+/*
+ * Portions of this file are adapted from AndroidX Compose UI:
+ *  - the `boundsInWindow` extension is a faster copy of `LayoutCoordinates.boundsInWindow`
+ *  - the `fastMinOf`, `fastMaxOf`, `fastCoerceIn`, `fastCoerceAtLeast` and `fastCoerceAtMost`
+ *    helpers are copied from `androidx.compose.ui.util.MathHelpers`
+ *
+ * Adapted from:
+ * https://github.com/androidx/androidx/blob/fc7df0dd68466ac3bb16b1c79b7a73dd0bfdd4c1/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/layout/LayoutCoordinates.kt
+ * https://github.com/androidx/androidx/blob/androidx-main/compose/ui/ui-util/src/commonMain/kotlin/androidx/compose/ui/util/MathHelpers.kt
+ *
+ * Copyright (C) 2019, 2020 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ */
 @file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE") // to access internal vals and classes
 
 package io.sentry.android.replay.util

From 29f120b097b4bd6c870491f5dc35caf7b37a7609 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 9 Jun 2026 10:22:41 +0200
Subject: [PATCH 188/391] perf: Replace java.net.URI with custom string parsing
 in Dsn (#5448)

* perf: Replace java.net.URI with custom string parsing in Dsn

The Dsn constructor used `new URI(dsnString).normalize()` to parse the
DSN string, which is known to be slow on Android. Since `retrieveParsedDsn()`
is called on the main thread during `Sentry.init()` via
`preInitConfigurations()`, this directly impacts app startup time.

Replace the URI-based parsing with manual indexOf/substring operations.
The only remaining URI construction is from pre-parsed components
(`new URI(scheme, null, host, port, path, null, null)`), which is
significantly cheaper since the JDK doesn't need to re-parse a string.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* test: Add tests for custom DSN string parsing

Cover edge cases specific to the manual indexOf/substring parser:
null input, missing scheme separator, no slash after host, multiple
path segments, port with path, multiple double slashes, query string
with port, empty secret key, and a realistic Sentry DSN with org id.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* changelog: Add entry for custom DSN parser

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* fix(dsn): Strip URI fragments and support IPv6 hosts

Harden the custom DSN parser and convert its tests to Google Truth.

- Strip URI fragments (#...) alongside query strings so they no longer
  leak into the project id and corrupt the constructed Sentry URI.
- Detect bracketed IPv6 literal hosts when locating the port separator,
  restoring behavior that java.net.URI handled.
- Narrow the parse error handling from catch (Throwable) to the
  expected exceptions, which stops swallowing Error and removes the
  doubled exception message.
- Extract the parsing steps into focused private helpers.
- Convert DsnTest to Google Truth assertions.
- Move the changelog entry to the Unreleased section, since 8.43.0 and
  8.43.1 have already been released.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* test(dsn): Assert exception messages via Truth hasMessageThat

Follow Truth's recommended pattern for exception testing: catch with
assertFailsWith, then assert on the caught throwable with
assertThat(ex).hasMessageThat(). Also assert the message in the
previously bare throw-only cases so they can no longer pass on an
unrelated exception.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(dsn): Give a clear error message for a malformed port

Parse the port in a dedicated helper that reports the offending value
("Invalid DSN: Invalid port 'abc'.") instead of leaking the raw
NumberFormatException text. Narrow the catch to URISyntaxException now
that the port is the only parseInt, and add a test.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                              |   4 +
 gradle/libs.versions.toml                 |   1 +
 sentry/build.gradle.kts                   |   1 +
 sentry/src/main/java/io/sentry/Dsn.java   | 161 ++++++++++++-------
 sentry/src/test/java/io/sentry/DsnTest.kt | 182 +++++++++++++++++-----
 5 files changed, 255 insertions(+), 94 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d80037414db..be4a5f7628d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Improvements
+
+- Improve SDK init performance by replacing `java.net.URI` with custom string parsing for DSN ([#5448](https://github.com/getsentry/sentry-java/pull/5448))
+
 ### Fixes
 
 - Session Replay: Fix `VerifyError` in Compose masking under DexGuard/R8 obfuscation ([#5507](https://github.com/getsentry/sentry-java/pull/5507))
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 7ee39d75ede..e653069e2b3 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -238,6 +238,7 @@ camerax-camera2 = { module = "androidx.camera:camera-camera2", version.ref = "ca
 camerax-lifecycle = { module = "androidx.camera:camera-lifecycle", version.ref = "camerax" }
 camerax-view = { module = "androidx.camera:camera-view", version.ref = "camerax" }
 
+google-truth = { module = "com.google.truth:truth", version = "1.4.5" }
 hsqldb = { module = "org.hsqldb:hsqldb", version = "2.6.1" }
 javafaker = { module = "com.github.javafaker:javafaker", version = "1.0.2" }
 kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" }
diff --git a/sentry/build.gradle.kts b/sentry/build.gradle.kts
index 25e700995b4..4c237803a51 100644
--- a/sentry/build.gradle.kts
+++ b/sentry/build.gradle.kts
@@ -25,6 +25,7 @@ dependencies {
   // tests
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(libs.awaitility.kotlin)
+  testImplementation(libs.google.truth)
   testImplementation(libs.javafaker)
   testImplementation(libs.kotlin.test.junit)
   testImplementation(libs.mockito.kotlin)
diff --git a/sentry/src/main/java/io/sentry/Dsn.java b/sentry/src/main/java/io/sentry/Dsn.java
index 0d21499b5fc..15aea2a064c 100644
--- a/sentry/src/main/java/io/sentry/Dsn.java
+++ b/sentry/src/main/java/io/sentry/Dsn.java
@@ -2,6 +2,7 @@
 
 import io.sentry.util.Objects;
 import java.net.URI;
+import java.net.URISyntaxException;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.jetbrains.annotations.NotNull;
@@ -17,98 +18,148 @@ final class Dsn {
   private final @NotNull URI sentryUri;
   private final @Nullable String orgId;
 
-  /*
-  / The project ID which the authenticated user is bound to.
-  */
+  /** The project ID which the authenticated user is bound to. */
   public @NotNull String getProjectId() {
     return projectId;
   }
 
-  /*
-  / An optional path of which Sentry is hosted
-  */
+  /** An optional path of which Sentry is hosted. */
   public @Nullable String getPath() {
     return path;
   }
 
-  /*
-  / The optional secret key to authenticate the SDK.
-  */
+  /** The optional secret key to authenticate the SDK. */
   public @Nullable String getSecretKey() {
     return secretKey;
   }
 
-  /*
-  / The required public key to authenticate the SDK.
-  */
+  /** The required public key to authenticate the SDK. */
   public @NotNull String getPublicKey() {
     return publicKey;
   }
 
-  /*
-  / The URI used to communicate with Sentry
-  */
+  /** The org ID extracted from the host, or {@code null} when the host has no org prefix. */
+  public @Nullable String getOrgId() {
+    return orgId;
+  }
+
+  /** The URI used to communicate with Sentry. */
   @NotNull
   URI getSentryUri() {
     return sentryUri;
   }
 
+  // Avoids java.net.URI for DSN parsing, which is slow on Android.
   Dsn(@Nullable String dsn) throws IllegalArgumentException {
+    final String dsnString = Objects.requireNonNull(dsn, "The DSN is required.").trim();
+    if (dsnString.isEmpty()) {
+      throw new IllegalArgumentException("The DSN is empty.");
+    }
+
     try {
-      final String dsnString = Objects.requireNonNull(dsn, "The DSN is required.").trim();
-      if (dsnString.isEmpty()) {
-        throw new IllegalArgumentException("The DSN is empty.");
+      final int schemeEnd = dsnString.indexOf("://");
+      if (schemeEnd < 0) {
+        throw new IllegalArgumentException("Invalid DSN: Missing scheme.");
       }
-      final URI uri = new URI(dsnString).normalize();
-      final String scheme = uri.getScheme();
-      if (!("http".equalsIgnoreCase(scheme) || "https".equalsIgnoreCase(scheme))) {
-        throw new IllegalArgumentException("Invalid DSN scheme: " + scheme);
+      final String scheme = dsnString.substring(0, schemeEnd);
+      if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)) {
+        throw new IllegalArgumentException("Invalid DSN: Invalid scheme '" + scheme + "'.");
       }
 
-      String userInfo = uri.getUserInfo();
-      if (userInfo == null || userInfo.isEmpty()) {
+      final int authStart = schemeEnd + 3;
+      final int atIndex = dsnString.indexOf('@', authStart);
+      if (atIndex < 0) {
         throw new IllegalArgumentException("Invalid DSN: No public key provided.");
       }
-      String[] keys = userInfo.split(":", -1);
-      publicKey = keys[0];
-      if (publicKey == null || publicKey.isEmpty()) {
+      final String userInfo = dsnString.substring(authStart, atIndex);
+      final int colonIndex = userInfo.indexOf(':');
+      publicKey = colonIndex < 0 ? userInfo : userInfo.substring(0, colonIndex);
+      secretKey = colonIndex < 0 ? null : userInfo.substring(colonIndex + 1);
+      if (publicKey.isEmpty()) {
         throw new IllegalArgumentException("Invalid DSN: No public key provided.");
       }
-      secretKey = keys.length > 1 ? keys[1] : null;
-      String uriPath = uri.getPath();
-      if (uriPath.endsWith("/")) {
-        uriPath = uriPath.substring(0, uriPath.length() - 1);
-      }
-      int projectIdStart = uriPath.lastIndexOf("/") + 1;
-      String path = uriPath.substring(0, projectIdStart);
-      if (!path.endsWith("/")) {
-        path += "/";
+
+      final String hostAndPath = stripQueryAndFragment(dsnString, atIndex + 1);
+      final int firstSlash = hostAndPath.indexOf('/');
+      if (firstSlash < 0) {
+        throw new IllegalArgumentException("Invalid DSN: A Project Id is required.");
       }
-      this.path = path;
-      projectId = uriPath.substring(projectIdStart);
+
+      final String hostPort = hostAndPath.substring(0, firstSlash);
+      final int portColon = portSeparatorIndex(hostPort);
+      final String host = portColon < 0 ? hostPort : hostPort.substring(0, portColon);
+      final int port = portColon < 0 ? -1 : parsePort(hostPort.substring(portColon + 1));
+
+      final String rawPath = stripTrailingSlash(collapseSlashes(hostAndPath.substring(firstSlash)));
+      final int projectIdStart = rawPath.lastIndexOf('/') + 1;
+      path = ensureTrailingSlash(rawPath.substring(0, projectIdStart));
+      projectId = rawPath.substring(projectIdStart);
       if (projectId.isEmpty()) {
         throw new IllegalArgumentException("Invalid DSN: A Project Id is required.");
       }
-      sentryUri =
-          new URI(
-              scheme, null, uri.getHost(), uri.getPort(), path + "api/" + projectId, null, null);
-
-      // Extract org ID from host (e.g., "o123.ingest.sentry.io" -> "123")
-      String extractedOrgId = null;
-      final String host = uri.getHost();
-      if (host != null) {
-        final Matcher matcher = ORG_ID_PATTERN.matcher(host);
-        if (matcher.find()) {
-          extractedOrgId = matcher.group(1);
-        }
+
+      sentryUri = new URI(scheme, null, host, port, path + "api/" + projectId, null, null);
+      orgId = extractOrgId(host);
+    } catch (URISyntaxException e) {
+      throw new IllegalArgumentException("Invalid DSN: " + e.getMessage(), e);
+    }
+  }
+
+  private static int parsePort(final @NotNull String portString) {
+    try {
+      return Integer.parseInt(portString);
+    } catch (NumberFormatException e) {
+      throw new IllegalArgumentException("Invalid DSN: Invalid port '" + portString + "'.", e);
+    }
+  }
+
+  // Drops the query string and/or fragment, whichever appears first, from the host onwards.
+  private static @NotNull String stripQueryAndFragment(
+      final @NotNull String dsn, final int fromIndex) {
+    int cut = dsn.indexOf('?', fromIndex);
+    final int fragment = dsn.indexOf('#', fromIndex);
+    if (fragment >= 0 && (cut < 0 || fragment < cut)) {
+      cut = fragment;
+    }
+    return cut < 0 ? dsn.substring(fromIndex) : dsn.substring(fromIndex, cut);
+  }
+
+  // IPv6 literals are bracketed and contain colons, so the port separator follows the ']'.
+  private static int portSeparatorIndex(final @NotNull String hostPort) {
+    return hostPort.startsWith("[")
+        ? hostPort.indexOf(':', hostPort.indexOf(']'))
+        : hostPort.indexOf(':');
+  }
+
+  // Collapses runs of slashes into a single slash, like URI.normalize().
+  private static @NotNull String collapseSlashes(final @NotNull String path) {
+    if (!path.contains("//")) {
+      return path;
+    }
+    final StringBuilder sb = new StringBuilder(path.length());
+    char previous = 0;
+    for (int i = 0; i < path.length(); i++) {
+      final char c = path.charAt(i);
+      if (c == '/' && previous == '/') {
+        continue;
       }
-      orgId = extractedOrgId;
-    } catch (Throwable e) {
-      throw new IllegalArgumentException(e);
+      sb.append(c);
+      previous = c;
     }
+    return sb.toString();
   }
 
-  public @Nullable String getOrgId() {
-    return orgId;
+  private static @NotNull String stripTrailingSlash(final @NotNull String path) {
+    return path.endsWith("/") ? path.substring(0, path.length() - 1) : path;
+  }
+
+  private static @NotNull String ensureTrailingSlash(final @NotNull String path) {
+    return path.endsWith("/") ? path : path + "/";
+  }
+
+  // Extracts the org ID from a host such as "o123.ingest.sentry.io" -> "123".
+  private static @Nullable String extractOrgId(final @NotNull String host) {
+    final Matcher matcher = ORG_ID_PATTERN.matcher(host);
+    return matcher.find() ? matcher.group(1) : null;
   }
 }
diff --git a/sentry/src/test/java/io/sentry/DsnTest.kt b/sentry/src/test/java/io/sentry/DsnTest.kt
index 7e2982073f1..f8195d16af6 100644
--- a/sentry/src/test/java/io/sentry/DsnTest.kt
+++ b/sentry/src/test/java/io/sentry/DsnTest.kt
@@ -1,21 +1,20 @@
 package io.sentry
 
+import com.google.common.truth.Truth.assertThat
 import java.lang.IllegalArgumentException
 import kotlin.test.Test
-import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
-import kotlin.test.assertNull
 
 class DsnTest {
   @Test
   fun `dsn parsed with path, sets all properties`() {
     val dsn = Dsn("https://publicKey:secretKey@host/path/id")
 
-    assertEquals("https://host/path/api/id", dsn.sentryUri.toURL().toString())
-    assertEquals("publicKey", dsn.publicKey)
-    assertEquals("secretKey", dsn.secretKey)
-    assertEquals("/path/", dsn.path)
-    assertEquals("id", dsn.projectId)
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://host/path/api/id")
+    assertThat(dsn.publicKey).isEqualTo("publicKey")
+    assertThat(dsn.secretKey).isEqualTo("secretKey")
+    assertThat(dsn.path).isEqualTo("/path/")
+    assertThat(dsn.projectId).isEqualTo("id")
   }
 
   @Test
@@ -23,94 +22,90 @@ class DsnTest {
     // query strings were once a feature, but no more
     val dsn = Dsn("https://publicKey:secretKey@host/path/id?sample.rate=0.1")
 
-    assertEquals("https://host/path/api/id", dsn.sentryUri.toURL().toString())
-    assertEquals("publicKey", dsn.publicKey)
-    assertEquals("secretKey", dsn.secretKey)
-    assertEquals("/path/", dsn.path)
-    assertEquals("id", dsn.projectId)
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://host/path/api/id")
+    assertThat(dsn.publicKey).isEqualTo("publicKey")
+    assertThat(dsn.secretKey).isEqualTo("secretKey")
+    assertThat(dsn.path).isEqualTo("/path/")
+    assertThat(dsn.projectId).isEqualTo("id")
   }
 
   @Test
   fun `dsn parsed without path`() {
     val dsn = Dsn("https://key@host/id")
-    assertEquals("https://host/api/id", dsn.sentryUri.toURL().toString())
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://host/api/id")
   }
 
   @Test
   fun `dsn parsed with port number`() {
     val dsn = Dsn("http://key@host:69/id")
-    assertEquals("http://host:69/api/id", dsn.sentryUri.toURL().toString())
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("http://host:69/api/id")
   }
 
   @Test
   fun `dsn parsed with trailing slash`() {
     val dsn = Dsn("http://key@host/id/")
-    assertEquals("http://host/api/id", dsn.sentryUri.toURL().toString())
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("http://host/api/id")
   }
 
   @Test
   fun `dsn parsed with no delimiter for key`() {
     val dsn = Dsn("https://publicKey@host/id")
 
-    assertEquals("publicKey", dsn.publicKey)
-    assertNull(dsn.secretKey)
+    assertThat(dsn.publicKey).isEqualTo("publicKey")
+    assertThat(dsn.secretKey).isNull()
   }
 
   @Test
   fun `when no project id exists, throws exception`() {
     val ex = assertFailsWith<IllegalArgumentException> { Dsn("http://key@host/") }
-    assertEquals(
-      "java.lang.IllegalArgumentException: Invalid DSN: A Project Id is required.",
-      ex.message,
-    )
+    assertThat(ex).hasMessageThat().isEqualTo("Invalid DSN: A Project Id is required.")
   }
 
   @Test
   fun `when no key exists, throws exception`() {
     val ex = assertFailsWith<IllegalArgumentException> { Dsn("http://host/id") }
-    assertEquals(
-      "java.lang.IllegalArgumentException: Invalid DSN: No public key provided.",
-      ex.message,
-    )
+    assertThat(ex).hasMessageThat().isEqualTo("Invalid DSN: No public key provided.")
   }
 
   @Test
   fun `when only passing secret key, throws exception`() {
     val ex = assertFailsWith<IllegalArgumentException> { Dsn("https://:secret@host/path/id") }
-    assertEquals(
-      "java.lang.IllegalArgumentException: Invalid DSN: No public key provided.",
-      ex.message,
-    )
+    assertThat(ex).hasMessageThat().isEqualTo("Invalid DSN: No public key provided.")
   }
 
   @Test
   fun `dsn is normalized`() {
     val dsn = Dsn("http://key@host//id")
-    assertEquals("http://host/api/id", dsn.sentryUri.toURL().toString())
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("http://host/api/id")
   }
 
   @Test
   fun `dsn parsed with leading and trailing whitespace`() {
     val dsn = Dsn("  https://key@host/id  ")
-    assertEquals("https://host/api/id", dsn.sentryUri.toURL().toString())
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://host/api/id")
   }
 
   @Test
   fun `when dsn is empty, throws exception`() {
     val ex = assertFailsWith<IllegalArgumentException> { Dsn("") }
-    assertEquals("java.lang.IllegalArgumentException: The DSN is empty.", ex.message)
+    assertThat(ex).hasMessageThat().isEqualTo("The DSN is empty.")
   }
 
   @Test
   fun `when dsn is only whitespace, throws exception`() {
     val ex = assertFailsWith<IllegalArgumentException> { Dsn("   ") }
-    assertEquals("java.lang.IllegalArgumentException: The DSN is empty.", ex.message)
+    assertThat(ex).hasMessageThat().isEqualTo("The DSN is empty.")
   }
 
   @Test
   fun `non http protocols are not accepted`() {
-    assertFailsWith<IllegalArgumentException> { Dsn("ftp://publicKey:secretKey@host/path/id") }
-    assertFailsWith<IllegalArgumentException> { Dsn("jar://publicKey:secretKey@host/path/id") }
+    val ftp =
+      assertFailsWith<IllegalArgumentException> { Dsn("ftp://publicKey:secretKey@host/path/id") }
+    assertThat(ftp).hasMessageThat().isEqualTo("Invalid DSN: Invalid scheme 'ftp'.")
+
+    val jar =
+      assertFailsWith<IllegalArgumentException> { Dsn("jar://publicKey:secretKey@host/path/id") }
+    assertThat(jar).hasMessageThat().isEqualTo("Invalid DSN: Invalid scheme 'jar'.")
   }
 
   @Test
@@ -125,24 +120,133 @@ class DsnTest {
   @Test
   fun `extracts org id from host`() {
     val dsn = Dsn("https://key@o123.ingest.sentry.io/456")
-    assertEquals("123", dsn.orgId)
+    assertThat(dsn.orgId).isEqualTo("123")
   }
 
   @Test
   fun `extracts single digit org id from host`() {
     val dsn = Dsn("https://key@o1.ingest.us.sentry.io/456")
-    assertEquals("1", dsn.orgId)
+    assertThat(dsn.orgId).isEqualTo("1")
   }
 
   @Test
   fun `returns null org id when host has no org prefix`() {
     val dsn = Dsn("https://key@sentry.io/456")
-    assertNull(dsn.orgId)
+    assertThat(dsn.orgId).isNull()
   }
 
   @Test
   fun `returns null org id for non-standard host`() {
     val dsn = Dsn("http://key@localhost:9000/456")
-    assertNull(dsn.orgId)
+    assertThat(dsn.orgId).isNull()
+  }
+
+  @Test
+  fun `when dsn is null, throws exception`() {
+    val ex = assertFailsWith<IllegalArgumentException> { Dsn(null) }
+    assertThat(ex).hasMessageThat().isEqualTo("The DSN is required.")
+  }
+
+  @Test
+  fun `when dsn has no scheme separator, throws exception`() {
+    val ex = assertFailsWith<IllegalArgumentException> { Dsn("httpspublicKey@host/id") }
+    assertThat(ex).hasMessageThat().isEqualTo("Invalid DSN: Missing scheme.")
+  }
+
+  @Test
+  fun `when dsn has no slash after host, throws exception`() {
+    val ex = assertFailsWith<IllegalArgumentException> { Dsn("https://key@host") }
+    assertThat(ex).hasMessageThat().isEqualTo("Invalid DSN: A Project Id is required.")
+  }
+
+  @Test
+  fun `when port is not a number, throws exception`() {
+    val ex = assertFailsWith<IllegalArgumentException> { Dsn("http://key@host:abc/1") }
+    assertThat(ex).hasMessageThat().isEqualTo("Invalid DSN: Invalid port 'abc'.")
+  }
+
+  @Test
+  fun `dsn parsed with multiple path segments`() {
+    val dsn = Dsn("https://key@host/path/to/sentry/id")
+
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://host/path/to/sentry/api/id")
+    assertThat(dsn.publicKey).isEqualTo("key")
+    assertThat(dsn.path).isEqualTo("/path/to/sentry/")
+    assertThat(dsn.projectId).isEqualTo("id")
+  }
+
+  @Test
+  fun `dsn parsed with port and path`() {
+    val dsn = Dsn("http://key:secret@host:8080/path/id")
+
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("http://host:8080/path/api/id")
+    assertThat(dsn.publicKey).isEqualTo("key")
+    assertThat(dsn.secretKey).isEqualTo("secret")
+    assertThat(dsn.path).isEqualTo("/path/")
+    assertThat(dsn.projectId).isEqualTo("id")
+  }
+
+  @Test
+  fun `dsn with multiple double slashes in path is normalized`() {
+    val dsn = Dsn("http://key@host//path//id")
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("http://host/path/api/id")
+  }
+
+  @Test
+  fun `dsn with query string and port`() {
+    val dsn = Dsn("https://key@host:443/id?foo=bar&baz=1")
+
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://host:443/api/id")
+    assertThat(dsn.projectId).isEqualTo("id")
+  }
+
+  @Test
+  fun `dsn with fragment is stripped from project id`() {
+    val dsn = Dsn("https://key@host/123#frag")
+
+    assertThat(dsn.projectId).isEqualTo("123")
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://host/api/123")
+  }
+
+  @Test
+  fun `dsn with both query string and fragment is stripped from project id`() {
+    val dsn = Dsn("https://key@host/123?foo=bar#frag")
+
+    assertThat(dsn.projectId).isEqualTo("123")
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://host/api/123")
+  }
+
+  @Test
+  fun `dsn with ipv6 host and port`() {
+    val dsn = Dsn("https://key@[2001:db8::1]:9000/1")
+
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://[2001:db8::1]:9000/api/1")
+    assertThat(dsn.projectId).isEqualTo("1")
+  }
+
+  @Test
+  fun `dsn with ipv6 host and no port`() {
+    val dsn = Dsn("https://key@[::1]/1")
+
+    assertThat(dsn.sentryUri.toURL().toString()).isEqualTo("https://[::1]/api/1")
+    assertThat(dsn.projectId).isEqualTo("1")
+  }
+
+  @Test
+  fun `dsn with empty secret key after colon`() {
+    val dsn = Dsn("https://publicKey:@host/id")
+
+    assertThat(dsn.publicKey).isEqualTo("publicKey")
+    assertThat(dsn.secretKey).isEqualTo("")
+  }
+
+  @Test
+  fun `dsn with numeric project id`() {
+    val dsn = Dsn("https://key@o123.ingest.sentry.io/1234567")
+
+    assertThat(dsn.projectId).isEqualTo("1234567")
+    assertThat(dsn.orgId).isEqualTo("123")
+    assertThat(dsn.sentryUri.toURL().toString())
+      .isEqualTo("https://o123.ingest.sentry.io/api/1234567")
   }
 }

From 887fd58186a83c5a1120c69813ba5eb7f1c097da Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 9 Jun 2026 11:25:49 +0200
Subject: [PATCH 189/391] ci(spring-matrix): Replace sed hacks with targeted
 Gradle builds (#5397)

* ci(spring-matrix): Replace sed hacks with targeted Gradle builds

Remove the sed-based Android module exclusion from settings.gradle.kts
and build.gradle.kts in the Spring Boot matrix workflows. This is
unnecessary because `org.gradle.configureondemand=true` ensures Gradle
only configures projects needed for the requested tasks.

Replace the broad `./gradlew assemble --parallel` with a single
targeted Gradle invocation that builds only the specific artifacts
needed (shadowJar/bootJar/war + OTel agent). Remove redundant
`--build "true"` from test runner invocations since artifacts are
already built.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ci(spring-matrix): Include testClasses in initial build

Add testClasses tasks to the single Gradle invocation so test
sources are pre-compiled. The subsequent systemTest Gradle calls
then only execute tests without needing to compile anything.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

* ci(spring-matrix): Remove redundant --parallel flag

Already set in gradle.properties.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>
---
 .github/workflows/spring-boot-2-matrix.yml | 64 +++++++---------------
 .github/workflows/spring-boot-3-matrix.yml | 64 +++++++---------------
 .github/workflows/spring-boot-4-matrix.yml | 64 +++++++---------------
 3 files changed, 57 insertions(+), 135 deletions(-)

diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index bbcb3cfc0bc..32eeef2442d 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -72,88 +72,62 @@ jobs:
           perl -0pi -e 'BEGIN { $v = shift } s/^springboot2[[:space:]]*=[[:space:]]*"\K[^"]*/$v/m or die "::error::springboot2 version entry not found in gradle/libs.versions.toml\n"' "$springboot_version" gradle/libs.versions.toml
           echo "Updated Spring Boot 2.x version to $springboot_version"
 
-      - name: Exclude android modules from build
+      - name: Build sample artifacts
         run: |
-          sed -i \
-            -e '/.*"sentry-android-ndk",/d' \
-            -e '/.*"sentry-android",/d' \
-            -e '/.*"sentry-compose",/d' \
-            -e '/.*"sentry-android-core",/d' \
-            -e '/.*"sentry-android-fragment",/d' \
-            -e '/.*"sentry-android-navigation",/d' \
-            -e '/.*"sentry-android-sqlite",/d' \
-            -e '/.*"sentry-android-timber",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android-benchmark",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android-critical",/d' \
-            -e '/.*"sentry-android-integration-tests:test-app-sentry",/d' \
-            -e '/.*"sentry-android-integration-tests:test-app-size",/d' \
-            -e '/.*"sentry-samples:sentry-samples-android",/d' \
-            -e '/.*"sentry-android-replay",/d' \
-            settings.gradle.kts
-
-      - name: Exclude android modules from ignore list
-        run: |
-          sed -i \
-            -e '/.*"sentry-uitest-android",/d' \
-            -e '/.*"sentry-uitest-android-benchmark",/d' \
-            -e '/.*"sentry-uitest-android-critical",/d' \
-            -e '/.*"test-app-sentry",/d' \
-            -e '/.*"test-app-size",/d' \
-            -e '/.*"sentry-samples-android",/d' \
-            build.gradle.kts
-
-      - name: Build SDK
-        run: |
-          ./gradlew assemble --parallel
+          ./gradlew \
+            :sentry-samples:sentry-samples-spring-boot:shadowJar \
+            :sentry-samples:sentry-samples-spring-boot:testClasses \
+            :sentry-samples:sentry-samples-spring-boot-webflux:shadowJar \
+            :sentry-samples:sentry-samples-spring-boot-webflux:testClasses \
+            :sentry-samples:sentry-samples-spring-boot-opentelemetry:shadowJar \
+            :sentry-samples:sentry-samples-spring-boot-opentelemetry:testClasses \
+            :sentry-samples:sentry-samples-spring-boot-opentelemetry-noagent:shadowJar \
+            :sentry-samples:sentry-samples-spring-boot-opentelemetry-noagent:testClasses \
+            :sentry-samples:sentry-samples-spring:war \
+            :sentry-samples:sentry-samples-spring:testClasses \
+            :sentry-opentelemetry:sentry-opentelemetry-agent:assemble
 
       - name: Test sentry-samples-spring-boot
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Test sentry-samples-spring-boot-webflux
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-webflux" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Test sentry-samples-spring-boot-opentelemetry agent init true
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-opentelemetry" \
             --agent true \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Test sentry-samples-spring-boot-opentelemetry agent init false
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-opentelemetry" \
             --agent true \
-            --auto-init "false" \
-            --build "true"
+            --auto-init "false"
 
       - name: Test sentry-samples-spring-boot-opentelemetry-noagent
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-opentelemetry-noagent" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Test sentry-samples-spring
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Upload test results
         if: always()
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 781d8a876f9..8614e2ca69d 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -68,88 +68,62 @@ jobs:
           perl -0pi -e 'BEGIN { $v = shift } s/^springboot3[[:space:]]*=[[:space:]]*"\K[^"]*/$v/m or die "::error::springboot3 version entry not found in gradle/libs.versions.toml\n"' "$springboot_version" gradle/libs.versions.toml
           echo "Updated Spring Boot 3.x version to $springboot_version"
 
-      - name: Exclude android modules from build
+      - name: Build sample artifacts
         run: |
-          sed -i \
-            -e '/.*"sentry-android-ndk",/d' \
-            -e '/.*"sentry-android",/d' \
-            -e '/.*"sentry-compose",/d' \
-            -e '/.*"sentry-android-core",/d' \
-            -e '/.*"sentry-android-fragment",/d' \
-            -e '/.*"sentry-android-navigation",/d' \
-            -e '/.*"sentry-android-sqlite",/d' \
-            -e '/.*"sentry-android-timber",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android-benchmark",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android-critical",/d' \
-            -e '/.*"sentry-android-integration-tests:test-app-sentry",/d' \
-            -e '/.*"sentry-android-integration-tests:test-app-size",/d' \
-            -e '/.*"sentry-samples:sentry-samples-android",/d' \
-            -e '/.*"sentry-android-replay",/d' \
-            settings.gradle.kts
-
-      - name: Exclude android modules from ignore list
-        run: |
-          sed -i \
-            -e '/.*"sentry-uitest-android",/d' \
-            -e '/.*"sentry-uitest-android-benchmark",/d' \
-            -e '/.*"sentry-uitest-android-critical",/d' \
-            -e '/.*"test-app-sentry",/d' \
-            -e '/.*"test-app-size",/d' \
-            -e '/.*"sentry-samples-android",/d' \
-            build.gradle.kts
-
-      - name: Build SDK
-        run: |
-          ./gradlew assemble --parallel
+          ./gradlew \
+            :sentry-samples:sentry-samples-spring-boot-jakarta:bootJar \
+            :sentry-samples:sentry-samples-spring-boot-jakarta:testClasses \
+            :sentry-samples:sentry-samples-spring-boot-webflux-jakarta:bootJar \
+            :sentry-samples:sentry-samples-spring-boot-webflux-jakarta:testClasses \
+            :sentry-samples:sentry-samples-spring-boot-jakarta-opentelemetry:bootJar \
+            :sentry-samples:sentry-samples-spring-boot-jakarta-opentelemetry:testClasses \
+            :sentry-samples:sentry-samples-spring-boot-jakarta-opentelemetry-noagent:bootJar \
+            :sentry-samples:sentry-samples-spring-boot-jakarta-opentelemetry-noagent:testClasses \
+            :sentry-samples:sentry-samples-spring-jakarta:war \
+            :sentry-samples:sentry-samples-spring-jakarta:testClasses \
+            :sentry-opentelemetry:sentry-opentelemetry-agent:assemble
 
       - name: Test sentry-samples-spring-boot-jakarta
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-jakarta" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Test sentry-samples-spring-boot-webflux-jakarta
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-webflux-jakarta" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Test sentry-samples-spring-boot-jakarta-opentelemetry agent init true
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-jakarta-opentelemetry" \
             --agent true \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Test sentry-samples-spring-boot-jakarta-opentelemetry agent init false
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-jakarta-opentelemetry" \
             --agent true \
-            --auto-init "false" \
-            --build "true"
+            --auto-init "false"
 
       - name: Test sentry-samples-spring-boot-jakarta-opentelemetry-noagent
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-jakarta-opentelemetry-noagent" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Test sentry-samples-spring-jakarta
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-jakarta" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Upload test results
         if: always()
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index bc1b1686692..e82b120ec24 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -68,88 +68,62 @@ jobs:
           perl -0pi -e 'BEGIN { $v = shift } s/^springboot4[[:space:]]*=[[:space:]]*"\K[^"]*/$v/m or die "::error::springboot4 version entry not found in gradle/libs.versions.toml\n"' "$springboot_version" gradle/libs.versions.toml
           echo "Updated Spring Boot 4.x version to $springboot_version"
 
-      - name: Exclude android modules from build
+      - name: Build sample artifacts
         run: |
-          sed -i \
-            -e '/.*"sentry-android-ndk",/d' \
-            -e '/.*"sentry-android",/d' \
-            -e '/.*"sentry-compose",/d' \
-            -e '/.*"sentry-android-core",/d' \
-            -e '/.*"sentry-android-fragment",/d' \
-            -e '/.*"sentry-android-navigation",/d' \
-            -e '/.*"sentry-android-sqlite",/d' \
-            -e '/.*"sentry-android-timber",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android-benchmark",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android-critical",/d' \
-            -e '/.*"sentry-android-integration-tests:test-app-sentry",/d' \
-            -e '/.*"sentry-android-integration-tests:test-app-size",/d' \
-            -e '/.*"sentry-samples:sentry-samples-android",/d' \
-            -e '/.*"sentry-android-replay",/d' \
-            settings.gradle.kts
-
-      - name: Exclude android modules from ignore list
-        run: |
-          sed -i \
-            -e '/.*"sentry-uitest-android",/d' \
-            -e '/.*"sentry-uitest-android-benchmark",/d' \
-            -e '/.*"sentry-uitest-android-critical",/d' \
-            -e '/.*"test-app-sentry",/d' \
-            -e '/.*"test-app-size",/d' \
-            -e '/.*"sentry-samples-android",/d' \
-            build.gradle.kts
-
-      - name: Build SDK
-        run: |
-          ./gradlew assemble --parallel
+          ./gradlew \
+            :sentry-samples:sentry-samples-spring-boot-4:bootJar \
+            :sentry-samples:sentry-samples-spring-boot-4:testClasses \
+            :sentry-samples:sentry-samples-spring-boot-4-webflux:bootJar \
+            :sentry-samples:sentry-samples-spring-boot-4-webflux:testClasses \
+            :sentry-samples:sentry-samples-spring-boot-4-opentelemetry:bootJar \
+            :sentry-samples:sentry-samples-spring-boot-4-opentelemetry:testClasses \
+            :sentry-samples:sentry-samples-spring-boot-4-opentelemetry-noagent:bootJar \
+            :sentry-samples:sentry-samples-spring-boot-4-opentelemetry-noagent:testClasses \
+            :sentry-samples:sentry-samples-spring-7:war \
+            :sentry-samples:sentry-samples-spring-7:testClasses \
+            :sentry-opentelemetry:sentry-opentelemetry-agent:assemble
 
       - name: Run sentry-samples-spring-boot-4
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-4" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Run sentry-samples-spring-boot-4-webflux
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-4-webflux" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Run sentry-samples-spring-boot-4-opentelemetry agent init true
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-4-opentelemetry" \
             --agent true \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Run sentry-samples-spring-boot-4-opentelemetry agent init false
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-4-opentelemetry" \
             --agent true \
-            --auto-init "false" \
-            --build "true"
+            --auto-init "false"
 
       - name: Run sentry-samples-spring-boot-4-opentelemetry-noagent
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-boot-4-opentelemetry-noagent" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Run sentry-samples-spring-7
         run: |
           python3 test/system-test-runner.py test \
             --module "sentry-samples-spring-7" \
             --agent false \
-            --auto-init "true" \
-            --build "true"
+            --auto-init "true"
 
       - name: Upload test results
         if: always()

From 0456f5cda95b2b91962216f24628a5ecfbebd594 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 10 Jun 2026 10:06:41 +0200
Subject: [PATCH 190/391] chore(deps): bump the github-actions group across 1
 directory with 3 updates (#5519)

Bumps the github-actions group with 3 updates in the / directory: [codecov/codecov-action](https://github.com/codecov/codecov-action), [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) and [getsentry/craft](https://github.com/getsentry/craft).


Updates `codecov/codecov-action` from 6.0.1 to 7.0.0
- [Release notes](https://github.com/codecov/codecov-action/releases)
- [Changelog](https://github.com/codecov/codecov-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/codecov/codecov-action/compare/e79a6962e0d4c0c17b229090214935d2e33f8354...fb8b3582c8e4def4969c97caa2f19720cb33a72f)

Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.26.8 to 2.26.9
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/4468eb9e399655a61c770534dacc03139d98aa18...6143e76379c342e247687c4ab5c83d8b900cc273)

Updates `getsentry/craft` from 2.26.8 to 2.26.9
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/4468eb9e399655a61c770534dacc03139d98aa18...6143e76379c342e247687c4ab5c83d8b900cc273)

---
updated-dependencies:
- dependency-name: codecov/codecov-action
  dependency-version: 7.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.26.9
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: getsentry/craft
  dependency-version: 2.26.9
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/build.yml             | 2 +-
 .github/workflows/changelog-preview.yml | 2 +-
 .github/workflows/release.yml           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 2d9e2a3ba38..bb1f45dd60d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -58,7 +58,7 @@ jobs:
           SENTRY_PROJECT: sentry-android
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@e79a6962e0d4c0c17b229090214935d2e33f8354 # pin@v4
+        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # pin@v4
         with:
           name: sentry-java
           fail_ci_if_error: false
diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index 612cc5b52f3..ad0c577b29f 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@4468eb9e399655a61c770534dacc03139d98aa18 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@6143e76379c342e247687c4ab5c83d8b900cc273 # v2
     secrets: inherit
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index a6964cec4ba..36732d3874d 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@4468eb9e399655a61c770534dacc03139d98aa18 # v2
+        uses: getsentry/craft@6143e76379c342e247687c4ab5c83d8b900cc273 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From 3594cd9accff22d8fc383bafc87965ec3b2f8d83 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 10 Jun 2026 14:25:15 +0200
Subject: [PATCH 191/391] ref(core): Reduce unnecessary boxing and redundant
 null checks (JAVA-554) (#5520)

* ref(core): Use static compare and drop redundant null checks

Replace boxed Long.valueOf(...).compareTo(...) with Long.compare(...),
which avoids the unnecessary boxing. Also remove the redundant != null
checks that precede an instanceof, since instanceof already returns
false for null.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* ref(core): Remove unnecessary boxing (JAVA-554)

Replace Integer.valueOf/Double.valueOf boxing with primitives or the
appropriate parse method. String.format takes the primitives directly,
the double conversions only need a cast, and the version check parses
straight to a primitive double via Double.parseDouble.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

* ref(core): Drop redundant StringBuilder in hashing helper (JAVA-554)

Return the hex string directly instead of wrapping it in a StringBuilder
only to immediately call toString().

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* ref(core): Use StandardCharsets.UTF_8 and tidy comments (JAVA-554)

Replace Charset.forName("UTF-8") with the StandardCharsets constant,
which avoids the lookup and cannot throw a checked exception. Also
collapse the leftover hashing comments into one.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                           |  1 +
 sentry/src/main/java/io/sentry/CircularFifoQueue.java  |  3 +--
 sentry/src/main/java/io/sentry/DateUtils.java          |  4 ++--
 .../src/main/java/io/sentry/ScopesStorageFactory.java  |  2 +-
 sentry/src/main/java/io/sentry/SentryDate.java         |  2 +-
 sentry/src/main/java/io/sentry/SentryNanotimeDate.java |  6 +++---
 sentry/src/main/java/io/sentry/SpanFactoryFactory.java |  2 +-
 .../eventprocessor/EventProcessorAndOrder.java         |  2 +-
 sentry/src/main/java/io/sentry/protocol/Contexts.java  |  2 +-
 .../src/main/java/io/sentry/util/LifecycleHelper.java  |  2 +-
 sentry/src/main/java/io/sentry/util/Platform.java      |  2 +-
 sentry/src/main/java/io/sentry/util/StringUtils.java   | 10 ++++------
 12 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index be4a5f7628d..6a813a8e7b6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Improvements
 
 - Improve SDK init performance by replacing `java.net.URI` with custom string parsing for DSN ([#5448](https://github.com/getsentry/sentry-java/pull/5448))
+- Remove unnecessary boxing to improve performance ([#5520](https://github.com/getsentry/sentry-java/pull/5520))
 
 ### Fixes
 
diff --git a/sentry/src/main/java/io/sentry/CircularFifoQueue.java b/sentry/src/main/java/io/sentry/CircularFifoQueue.java
index 8fa72e39d56..4c6a123d512 100644
--- a/sentry/src/main/java/io/sentry/CircularFifoQueue.java
+++ b/sentry/src/main/java/io/sentry/CircularFifoQueue.java
@@ -258,8 +258,7 @@ public boolean add(final @NotNull E element) {
     if (index < 0 || index >= sz) {
       throw new NoSuchElementException(
           String.format(
-              "The specified index (%1$d) is outside the available range [0, %2$d)",
-              Integer.valueOf(index), Integer.valueOf(sz)));
+              "The specified index (%1$d) is outside the available range [0, %2$d)", index, sz));
     }
 
     final int idx = (start + index) % maxElements;
diff --git a/sentry/src/main/java/io/sentry/DateUtils.java b/sentry/src/main/java/io/sentry/DateUtils.java
index 31a8dcd76ea..f7c46844edc 100644
--- a/sentry/src/main/java/io/sentry/DateUtils.java
+++ b/sentry/src/main/java/io/sentry/DateUtils.java
@@ -115,7 +115,7 @@ public static double nanosToMillis(final double nanos) {
    * @return date rounded down to milliseconds
    */
   public static Date nanosToDate(final long nanos) {
-    final Double millis = nanosToMillis(Double.valueOf(nanos));
+    final Double millis = nanosToMillis((double) nanos);
     return getDateTime(millis.longValue());
   }
 
@@ -137,7 +137,7 @@ public static Date nanosToDate(final long nanos) {
    * @return seconds
    */
   public static double nanosToSeconds(final long nanos) {
-    return Double.valueOf(nanos) / (1000.0 * 1000.0 * 1000.0);
+    return (double) nanos / (1000.0 * 1000.0 * 1000.0);
   }
 
   /**
diff --git a/sentry/src/main/java/io/sentry/ScopesStorageFactory.java b/sentry/src/main/java/io/sentry/ScopesStorageFactory.java
index 89fa6389072..37c0acf2314 100644
--- a/sentry/src/main/java/io/sentry/ScopesStorageFactory.java
+++ b/sentry/src/main/java/io/sentry/ScopesStorageFactory.java
@@ -29,7 +29,7 @@ public final class ScopesStorageFactory {
           try {
             final @Nullable Object otelScopesStorage =
                 otelScopesStorageClazz.getDeclaredConstructor().newInstance();
-            if (otelScopesStorage != null && otelScopesStorage instanceof IScopesStorage) {
+            if (otelScopesStorage instanceof IScopesStorage) {
               return (IScopesStorage) otelScopesStorage;
             }
           } catch (InstantiationException e) {
diff --git a/sentry/src/main/java/io/sentry/SentryDate.java b/sentry/src/main/java/io/sentry/SentryDate.java
index d2620ab3024..03ea596b07a 100644
--- a/sentry/src/main/java/io/sentry/SentryDate.java
+++ b/sentry/src/main/java/io/sentry/SentryDate.java
@@ -47,6 +47,6 @@ public final boolean isAfter(final @NotNull SentryDate otherDate) {
 
   @Override
   public int compareTo(@NotNull SentryDate otherDate) {
-    return Long.valueOf(nanoTimestamp()).compareTo(otherDate.nanoTimestamp());
+    return Long.compare(nanoTimestamp(), otherDate.nanoTimestamp());
   }
 }
diff --git a/sentry/src/main/java/io/sentry/SentryNanotimeDate.java b/sentry/src/main/java/io/sentry/SentryNanotimeDate.java
index 2993eeed6c6..98c46ad5325 100644
--- a/sentry/src/main/java/io/sentry/SentryNanotimeDate.java
+++ b/sentry/src/main/java/io/sentry/SentryNanotimeDate.java
@@ -46,7 +46,7 @@ public long nanoTimestamp() {
 
   @Override
   public long laterDateNanosTimestampByDiff(final @Nullable SentryDate otherDate) {
-    if (otherDate != null && otherDate instanceof SentryNanotimeDate) {
+    if (otherDate instanceof SentryNanotimeDate) {
       final @NotNull SentryNanotimeDate otherNanoDate = (SentryNanotimeDate) otherDate;
       if (compareTo(otherDate) < 0) {
         return nanotimeDiff(this, otherNanoDate);
@@ -66,9 +66,9 @@ public int compareTo(@NotNull SentryDate otherDate) {
       final long thisDateMillis = date.getTime();
       final long otherDateMillis = otherNanoDate.date.getTime();
       if (thisDateMillis == otherDateMillis) {
-        return Long.valueOf(nanos).compareTo(otherNanoDate.nanos);
+        return Long.compare(nanos, otherNanoDate.nanos);
       } else {
-        return Long.valueOf(thisDateMillis).compareTo(otherDateMillis);
+        return Long.compare(thisDateMillis, otherDateMillis);
       }
     } else {
       return super.compareTo(otherDate);
diff --git a/sentry/src/main/java/io/sentry/SpanFactoryFactory.java b/sentry/src/main/java/io/sentry/SpanFactoryFactory.java
index 7dbb9f1f588..f0e3fcbb3c7 100644
--- a/sentry/src/main/java/io/sentry/SpanFactoryFactory.java
+++ b/sentry/src/main/java/io/sentry/SpanFactoryFactory.java
@@ -21,7 +21,7 @@ public final class SpanFactoryFactory {
           try {
             final @Nullable Object otelSpanFactory =
                 otelSpanFactoryClazz.getDeclaredConstructor().newInstance();
-            if (otelSpanFactory != null && otelSpanFactory instanceof ISpanFactory) {
+            if (otelSpanFactory instanceof ISpanFactory) {
               return (ISpanFactory) otelSpanFactory;
             }
           } catch (InstantiationException e) {
diff --git a/sentry/src/main/java/io/sentry/internal/eventprocessor/EventProcessorAndOrder.java b/sentry/src/main/java/io/sentry/internal/eventprocessor/EventProcessorAndOrder.java
index 1f504f25557..1ca5f70df8f 100644
--- a/sentry/src/main/java/io/sentry/internal/eventprocessor/EventProcessorAndOrder.java
+++ b/sentry/src/main/java/io/sentry/internal/eventprocessor/EventProcessorAndOrder.java
@@ -29,6 +29,6 @@ public EventProcessorAndOrder(
 
   @Override
   public int compareTo(@NotNull EventProcessorAndOrder o) {
-    return order.compareTo(o.order);
+    return Long.compare(order, o.order);
   }
 }
diff --git a/sentry/src/main/java/io/sentry/protocol/Contexts.java b/sentry/src/main/java/io/sentry/protocol/Contexts.java
index fd1e9b83eb6..35168e5bcc2 100644
--- a/sentry/src/main/java/io/sentry/protocol/Contexts.java
+++ b/sentry/src/main/java/io/sentry/protocol/Contexts.java
@@ -282,7 +282,7 @@ public void putAll(final @Nullable Contexts contexts) {
 
   @Override
   public boolean equals(final @Nullable Object obj) {
-    if (obj != null && obj instanceof Contexts) {
+    if (obj instanceof Contexts) {
       final @NotNull Contexts otherContexts = (Contexts) obj;
       return internalStorage.equals(otherContexts.internalStorage);
     }
diff --git a/sentry/src/main/java/io/sentry/util/LifecycleHelper.java b/sentry/src/main/java/io/sentry/util/LifecycleHelper.java
index 4a029f620cc..fc6e9e74120 100644
--- a/sentry/src/main/java/io/sentry/util/LifecycleHelper.java
+++ b/sentry/src/main/java/io/sentry/util/LifecycleHelper.java
@@ -7,7 +7,7 @@
 public final class LifecycleHelper {
 
   public static void close(final @Nullable Object tokenObject) {
-    if (tokenObject != null && tokenObject instanceof ISentryLifecycleToken) {
+    if (tokenObject instanceof ISentryLifecycleToken) {
       final @NotNull ISentryLifecycleToken token = (ISentryLifecycleToken) tokenObject;
       token.close();
     }
diff --git a/sentry/src/main/java/io/sentry/util/Platform.java b/sentry/src/main/java/io/sentry/util/Platform.java
index b08b6e584fb..cc924fb2815 100644
--- a/sentry/src/main/java/io/sentry/util/Platform.java
+++ b/sentry/src/main/java/io/sentry/util/Platform.java
@@ -23,7 +23,7 @@ public final class Platform {
     try {
       final @Nullable String javaStringVersion = System.getProperty("java.specification.version");
       if (javaStringVersion != null) {
-        final @NotNull double javaVersion = Double.valueOf(javaStringVersion);
+        final @NotNull double javaVersion = Double.parseDouble(javaStringVersion);
         isJavaNinePlus = javaVersion >= 9.0;
       } else {
         isJavaNinePlus = false;
diff --git a/sentry/src/main/java/io/sentry/util/StringUtils.java b/sentry/src/main/java/io/sentry/util/StringUtils.java
index 66e3a95ddb7..02d7d4636a4 100644
--- a/sentry/src/main/java/io/sentry/util/StringUtils.java
+++ b/sentry/src/main/java/io/sentry/util/StringUtils.java
@@ -4,6 +4,7 @@
 import io.sentry.SentryLevel;
 import java.math.BigInteger;
 import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.text.CharacterIterator;
@@ -18,7 +19,7 @@
 @ApiStatus.Internal
 public final class StringUtils {
 
-  private static final Charset UTF_8 = Charset.forName("UTF-8");
+  private static final Charset UTF_8 = StandardCharsets.UTF_8;
 
   public static final String PROPER_NIL_UUID = "00000000-0000-0000-0000-000000000000";
   private static final String CORRUPTED_NIL_UUID = "0000-0000";
@@ -142,11 +143,8 @@ private StringUtils() {}
       // Convert byte array into signum representation
       final BigInteger no = new BigInteger(1, messageDigest);
 
-      // Convert message digest into hex value
-      final StringBuilder stringBuilder = new StringBuilder(no.toString(16));
-
-      // return the HashText
-      return stringBuilder.toString();
+      // Convert message digest into hex value and return the HashText
+      return no.toString(16);
     }
 
     // For specifying wrong message digest algorithms

From b88ded98ebe81fc24dde6129f8d397da9b1dcf61 Mon Sep 17 00:00:00 2001
From: markushi <1411808+markushi@users.noreply.github.com>
Date: Wed, 10 Jun 2026 12:38:25 +0000
Subject: [PATCH 192/391] release: 8.43.2

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6a813a8e7b6..1f7529b728f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.43.2
 
 ### Improvements
 
diff --git a/gradle.properties b/gradle.properties
index eee4b292bff..35641a00053 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.43.1
+versionName=8.43.2
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From a28ff1255339a733196c2151b2b56742aae1211e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 11 Jun 2026 09:23:15 +0200
Subject: [PATCH 193/391] chore(deps): bump the github-actions group with 2
 updates (#5526)

Bumps the github-actions group with 2 updates: [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) and [getsentry/craft](https://github.com/getsentry/craft).


Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.26.9 to 2.26.10
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/6143e76379c342e247687c4ab5c83d8b900cc273...acdb88019720182caf57293360d7cdc8db9e75ac)

Updates `getsentry/craft` from 2.26.9 to 2.26.10
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/6143e76379c342e247687c4ab5c83d8b900cc273...acdb88019720182caf57293360d7cdc8db9e75ac)

---
updated-dependencies:
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.26.10
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: getsentry/craft
  dependency-version: 2.26.10
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/changelog-preview.yml | 2 +-
 .github/workflows/release.yml           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index ad0c577b29f..d814ca72002 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@6143e76379c342e247687c4ab5c83d8b900cc273 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@acdb88019720182caf57293360d7cdc8db9e75ac # v2
     secrets: inherit
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 36732d3874d..eddeaa24cd9 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@6143e76379c342e247687c4ab5c83d8b900cc273 # v2
+        uses: getsentry/craft@acdb88019720182caf57293360d7cdc8db9e75ac # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From 8330a1be3553835c8c54fa993396afea48b0ef98 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 11 Jun 2026 09:33:11 +0200
Subject: [PATCH 194/391] ref(core): Avoid boxing in DateUtils.nanosToDate
 (#5523)

* ref(core): Avoid boxing in DateUtils.nanosToDate

nanosToMillis already returns a primitive double, but the result was
stored in a boxed Double and then unboxed again via longValue(). Keep
the value primitive to drop the redundant allocation and unboxing on
this conversion, which runs whenever a SentryDate is turned into a
java.util.Date.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  | 6 ++++++
 sentry/src/main/java/io/sentry/DateUtils.java | 4 ++--
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1f7529b728f..ba25b7d588a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Improvements
+
+- Reduce unboxing in `DateUtils.nanosToDate` ([#5523](https://github.com/getsentry/sentry-java/pull/5523))
+
 ## 8.43.2
 
 ### Improvements
diff --git a/sentry/src/main/java/io/sentry/DateUtils.java b/sentry/src/main/java/io/sentry/DateUtils.java
index f7c46844edc..5e55512ae70 100644
--- a/sentry/src/main/java/io/sentry/DateUtils.java
+++ b/sentry/src/main/java/io/sentry/DateUtils.java
@@ -115,8 +115,8 @@ public static double nanosToMillis(final double nanos) {
    * @return date rounded down to milliseconds
    */
   public static Date nanosToDate(final long nanos) {
-    final Double millis = nanosToMillis((double) nanos);
-    return getDateTime(millis.longValue());
+    final double millis = nanosToMillis((double) nanos);
+    return getDateTime((long) millis);
   }
 
   public static @Nullable Date toUtilDate(final @Nullable SentryDate sentryDate) {

From b988b37098f9350428c60c0d5ad8f8b11b872b84 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 11 Jun 2026 14:30:33 +0200
Subject: [PATCH 195/391] perf(core): Use fixed-delay scheduling for
 performance collector (JAVA-555) (#5524)

* perf(core): Use fixed-delay scheduling for performance collector

Switch the transaction collection timer from scheduleAtFixedRate to
schedule. Fixed-rate scheduling fires rapid catch-up executions after a
delay or GC pause, which the old code guarded against with a 10ms skip
check. Fixed-delay scheduling spaces each collection 100ms after the
previous one finishes, so the catch-up bursts cannot happen and the
guard, its timestamp field, and the stale comment are no longer needed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

* test(core): Verify schedule instead of scheduleAtFixedRate

The performance collector now uses fixed-delay scheduling, so the timer
verifications assert schedule(...) rather than scheduleAtFixedRate(...).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                     |  4 ++++
 .../DefaultCompositePerformanceCollector.java    | 11 +----------
 .../DefaultCompositePerformanceCollectorTest.kt  | 16 ++++++++--------
 3 files changed, 13 insertions(+), 18 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ba25b7d588a..407eb12d201 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,10 @@
 
 - Reduce unboxing in `DateUtils.nanosToDate` ([#5523](https://github.com/getsentry/sentry-java/pull/5523))
 
+### Fixes
+
+- Fix performance collector scheduling many tasks in a row ([#5524](https://github.com/getsentry/sentry-java/pull/5524))
+
 ## 8.43.2
 
 ### Improvements
diff --git a/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java b/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java
index 1861381a853..4736ab8fac5 100644
--- a/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java
+++ b/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java
@@ -27,7 +27,6 @@ public final class DefaultCompositePerformanceCollector implements CompositePerf
 
   private final @NotNull SentryOptions options;
   private final @NotNull AtomicBoolean isStarted = new AtomicBoolean(false);
-  private long lastCollectionTimestamp = 0;
 
   public DefaultCompositePerformanceCollector(final @NotNull SentryOptions options) {
     this.options = Objects.requireNonNull(options, "The options object is required.");
@@ -112,16 +111,8 @@ public void run() {
             new TimerTask() {
               @Override
               public void run() {
-                long now = System.currentTimeMillis();
-                // The timer is scheduled to run every 100ms on average. In case it takes longer,
-                // subsequent tasks are executed more quickly. If two tasks are scheduled to run in
-                // less than 10ms, the measurement that we collect is not meaningful, so we skip it
-                if (now - lastCollectionTimestamp <= 10) {
-                  return;
-                }
                 timedOutTransactions.clear();
 
-                lastCollectionTimestamp = now;
                 final @NotNull PerformanceCollectionData tempData =
                     new PerformanceCollectionData(options.getDateProvider().now().nanoTimestamp());
 
@@ -147,7 +138,7 @@ public void run() {
                 }
               }
             };
-        timer.scheduleAtFixedRate(
+        timer.schedule(
             timerTask,
             TRANSACTION_COLLECTION_INTERVAL_MILLIS,
             TRANSACTION_COLLECTION_INTERVAL_MILLIS);
diff --git a/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt b/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
index 46c304358df..ceec3571ebd 100644
--- a/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
+++ b/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
@@ -86,7 +86,7 @@ class DefaultCompositePerformanceCollectorTest {
     val collector = fixture.getSut(null, null)
     assertTrue(fixture.options.performanceCollectors.isEmpty())
     collector.start(fixture.transaction1)
-    verify(fixture.mockTimer, never())!!.scheduleAtFixedRate(any(), any<Long>(), any())
+    verify(fixture.mockTimer, never())!!.schedule(any(), any<Long>(), any())
   }
 
   @Test
@@ -104,14 +104,14 @@ class DefaultCompositePerformanceCollectorTest {
   fun `when start, timer is scheduled every 100 milliseconds`() {
     val collector = fixture.getSut()
     collector.start(fixture.transaction1)
-    verify(fixture.mockTimer)!!.scheduleAtFixedRate(any(), any<Long>(), eq(100))
+    verify(fixture.mockTimer)!!.schedule(any(), any<Long>(), eq(100))
   }
 
   @Test
   fun `when start with a string, timer is scheduled every 100 milliseconds`() {
     val collector = fixture.getSut()
     collector.start(fixture.id1)
-    verify(fixture.mockTimer)!!.scheduleAtFixedRate(any(), any<Long>(), eq(100))
+    verify(fixture.mockTimer)!!.schedule(any(), any<Long>(), eq(100))
   }
 
   @Test
@@ -119,7 +119,7 @@ class DefaultCompositePerformanceCollectorTest {
     val collector = fixture.getSut()
     collector.start(fixture.transaction1)
     collector.stop(fixture.transaction1)
-    verify(fixture.mockTimer)!!.scheduleAtFixedRate(any(), any<Long>(), eq(100))
+    verify(fixture.mockTimer)!!.schedule(any(), any<Long>(), eq(100))
     verify(fixture.mockTimer)!!.cancel()
   }
 
@@ -128,7 +128,7 @@ class DefaultCompositePerformanceCollectorTest {
     val collector = fixture.getSut()
     collector.start(fixture.id1)
     collector.stop(fixture.id1)
-    verify(fixture.mockTimer)!!.scheduleAtFixedRate(any(), any<Long>(), eq(100))
+    verify(fixture.mockTimer)!!.schedule(any(), any<Long>(), eq(100))
     verify(fixture.mockTimer)!!.cancel()
   }
 
@@ -136,7 +136,7 @@ class DefaultCompositePerformanceCollectorTest {
   fun `stopping a not collected transaction return null`() {
     val collector = fixture.getSut()
     val data = collector.stop(fixture.transaction1)
-    verify(fixture.mockTimer, never())!!.scheduleAtFixedRate(any(), any<Long>(), eq(100))
+    verify(fixture.mockTimer, never())!!.schedule(any(), any<Long>(), eq(100))
     verify(fixture.mockTimer, never())!!.cancel()
     assertNull(data)
   }
@@ -145,7 +145,7 @@ class DefaultCompositePerformanceCollectorTest {
   fun `stopping a not collected id return null`() {
     val collector = fixture.getSut()
     val data = collector.stop(fixture.id1)
-    verify(fixture.mockTimer, never())!!.scheduleAtFixedRate(any(), any<Long>(), eq(100))
+    verify(fixture.mockTimer, never())!!.schedule(any(), any<Long>(), eq(100))
     verify(fixture.mockTimer, never())!!.cancel()
     assertNull(data)
   }
@@ -316,7 +316,7 @@ class DefaultCompositePerformanceCollectorTest {
     collector.close()
 
     // Timer was canceled
-    verify(fixture.mockTimer)!!.scheduleAtFixedRate(any(), any<Long>(), eq(100))
+    verify(fixture.mockTimer)!!.schedule(any(), any<Long>(), eq(100))
     verify(fixture.mockTimer)!!.cancel()
 
     // Data was cleared

From 46b442bde01e6922493733151c6bb41106764cff Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 11 Jun 2026 16:49:14 +0200
Subject: [PATCH 196/391] ref(core): Use primitive long for
 EventProcessorAndOrder.order (#5527)

* ref(core): Use primitive long for EventProcessorAndOrder.order

Avoid boxing by storing the order as a primitive long instead of a
boxed Long. The constructor already normalizes a null order to
System.nanoTime(), so the field never needs to represent null.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

* changelog

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                                    | 2 +-
 .../sentry/internal/eventprocessor/EventProcessorAndOrder.java  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 407eb12d201..9b42d4bd09d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,7 @@
 
 ### Improvements
 
-- Reduce unboxing in `DateUtils.nanosToDate` ([#5523](https://github.com/getsentry/sentry-java/pull/5523))
+- Reduce boxing to improve performance ([#5523](https://github.com/getsentry/sentry-java/pull/5523), [#5527](https://github.com/getsentry/sentry-java/pull/5527))
 
 ### Fixes
 
diff --git a/sentry/src/main/java/io/sentry/internal/eventprocessor/EventProcessorAndOrder.java b/sentry/src/main/java/io/sentry/internal/eventprocessor/EventProcessorAndOrder.java
index 1ca5f70df8f..38ff7802f58 100644
--- a/sentry/src/main/java/io/sentry/internal/eventprocessor/EventProcessorAndOrder.java
+++ b/sentry/src/main/java/io/sentry/internal/eventprocessor/EventProcessorAndOrder.java
@@ -7,7 +7,7 @@
 public final class EventProcessorAndOrder implements Comparable<EventProcessorAndOrder> {
 
   private final @NotNull EventProcessor eventProcessor;
-  private final @NotNull Long order;
+  private final long order;
 
   public EventProcessorAndOrder(
       final @NotNull EventProcessor eventProcessor, final @Nullable Long order) {

From 85fd8b11a0c380fa02410ab8ac09a87d38a16e62 Mon Sep 17 00:00:00 2001
From: Giancarlo Buenaflor <giancarlo_buenaflor@yahoo.com>
Date: Fri, 12 Jun 2026 14:42:12 +0200
Subject: [PATCH 197/391] feat(android): Add standalone app start tracing
 (#5342)

* feat: Add standalone app start transaction (happy path)

Introduce experimental `enableStandaloneAppStartTracing` option that creates
a separate app start transaction instead of attaching app start as a child
span of the first activity transaction. This is the happy path only (foreground
importance, activity launch, first frame drawn as end time).

The standalone transaction shares the same trace ID as the activity transaction
but is not bound to the scope. App start measurements and child spans (process
init, content providers, application.onCreate) are attached to the standalone
transaction instead of the activity transaction.

Includes foreground importance check branching to prepare for the non-activity
launch path (next PR).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* feat: Add non-activity app start path with end time resolution

When the app starts without launching an activity (service, broadcast
receiver, content provider), create a standalone app start transaction
with the end time determined by priority:

1. onApplicationPostCreate (Gradle plugin bytecode instrumentation)
2. ApplicationStartInfo timestamps (API 35+)
3. firstIdle - main thread idle handler (pre-API 35 fallback)

The non-activity app start transaction stores its trace ID so that if
an activity is later launched, the activity transaction reuses the same
trace ID to keep both in the same trace.

Adds OnNoActivityStartedListener callback from AppStartMetrics to
ActivityLifecycleIntegration, triggered by checkCreateTimeOnMain()
when no activity was created after Application.onCreate().

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* feat: Support non-activity app start tracing without bytecode instrumentation

When an app is launched via broadcast receiver, service, or content provider
(no activity), detect this via Handler.post() and create a standalone app start
transaction. Resolves app start end time with priority: Gradle plugin >
ApplicationStartInfo (API 35+) > process init time. Also attaches child spans
(process init, content providers, Application.onCreate) to standalone
transactions.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* refactor: Consolidate non-activity app start time-span resolution

Extract the "try appStartSpan, fall back to sdkInitTimeSpan" logic used for
standalone (non-activity) app start transactions into a new
AppStartMetrics.getAppStartTimeSpanDirect() helper, removing the duplicated
inline fallback in ActivityLifecycleIntegration and the private helper in
PerformanceAndroidEventProcessor.

Also cache the API 35+ ApplicationStartInfo on registerLifecycleCallbacks so
onAppStartSpansSent no longer re-queries ActivityManager, and simplify the
non-activity detection path to always use the main-thread IdleHandler.

Regenerates the sentry-android-core API to include method additions missed in
prior commits on this branch (standalone-app-start options, trace id accessors,
OnNoActivityStartedListener).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* chore(samples): Register TestBroadcastReceiver in manifest

Wires up the TestBroadcastReceiver added earlier so the sample app can trigger
a non-activity cold start via `adb shell am broadcast`.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(app-start): resolve standalone tracing misclassification and duplicate emission

Two pre-merge fixes for the standalone app-start tracing path introduced on
this branch (issue #5046):

- AppStartMetrics.checkCreateTimeOnMain() now defaults appStartType to COLD
  when UNKNOWN with no active activities. On API < 35 (where
  ApplicationStartInfo is unavailable) non-activity cold starts were stuck
  at UNKNOWN, which both misclassified the standalone transaction as
  App Start Warm and caused PerformanceAndroidEventProcessor.attachAppStartSpans
  to early-return (dropping process.load / application.load / contentprovider.load
  phase spans).

- ActivityLifecycleIntegration.onActivityPreCreated() now skips emitting a
  second standalone App Start transaction when the non-activity path has
  already reported the process's app start (detected via the stashed
  appStartTraceId). Previously a broadcast followed by an activity launch
  produced two standalone transactions (a spurious App Start Warm in addition
  to the broadcast's App Start Cold), violating one-per-process semantics.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix(android): refine standalone app start tracing

* chore: Update generated files

* style(core): Apply spotless formatting

* changelog

* fix(android): Use stable app start transaction name

Rename the standalone app-start transaction to a single App Start name
so cold and warm starts group consistently while preserving the app.start op.

Co-authored-by: Cursor <cursoragent@cursor.com>

* feat(android): Add standalone app start tracing

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Handle non-activity app starts below API 24

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Guard app start timestamp clock base

Co-authored-by: Cursor <cursoragent@cursor.com>

* ref(android): Remove app start reason plumbing

Co-authored-by: Cursor <cursoragent@cursor.com>

* ref(android): Clarify no-activity app start handling

Rename the private app start helper to reflect that it conditionally
handles non-activity starts. Keep comments and tests focused on behavior.

Co-Authored-By: Claude <noreply@anthropic.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

* docs(android): Clarify non-activity app start fallback

Explain why unresolved non-activity starts default to cold when Activity
signals or ApplicationStartInfo classification are unavailable.

Co-Authored-By: Claude <noreply@anthropic.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Preserve legacy no-activity app start guard

Only run the no-activity startup check for unresolved app starts or when
standalone app start tracing registered a listener. This keeps API 35
ApplicationStartInfo classifications from triggering legacy side effects.

Co-Authored-By: Claude <noreply@anthropic.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

* test(android): Opt into standalone no-activity API 35 tests

Register a no-op no-activity listener for API 35 end-time resolution tests
so they exercise the standalone path under the restored legacy guard.

Co-Authored-By: Claude <noreply@anthropic.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Schedule no-activity idle check when standalone listener is set on API 35+

On API 35+, ApplicationStartInfo resolves appStartType before the
standalone app start listener is installed, causing the idle handler
condition to be false and skipping the no-activity detection entirely.

Register the idle handler from setOnNoActivityStartedListener when the
type is already resolved, ensuring onNoActivityStarted() fires for
standalone app start tracing on API 35+ devices.

Co-authored-by: Cursor <cursoragent@cursor.com>

* ref(android): Remove dead foregroundImportance check in standalone app start path

The foregroundImportance guard was always true at that point because
appStartTime is only set to non-null inside the foregroundImportance
branch. Remove the redundant check and the misleading else comment
that described an unreachable code path.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Prevent duplicate standalone app start measurements

Require the app-start pending flag even when standalone app-start transactions bypass foreground checks. Preserve completed non-activity app-start timings so fallback resolution does not overwrite stopped spans.

Co-authored-by: Cursor <cursoragent@cursor.com>

* ref(android): Remove unused app start application context

Drop dead AppStartMetrics state that was assigned during lifecycle callback registration but never read.

Co-authored-by: Cursor <cursoragent@cursor.com>

* ref(android): Rename getAppStartTimeSpanDirect to getAppStartTimeSpanForStandalone

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Do not set TTID/TTFD contributing flags on standalone app start spans

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Add volatile to noActivityStartedListener for cross-thread visibility

The field is written by setOnNoActivityStartedListener (called during
Sentry.init(), potentially on a background thread) and read on the main
thread in handleNoActivityStartIfNeededOnMain. Without volatile, the JMM
permits the main thread to see a stale null, silently skipping the
listener and preventing standalone app-start transaction creation.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Clear stale app start sampling decision in non-activity start path

onNoActivityStarted() did not clear the appStartSamplingDecision, which
could leak to the first ui.load transaction when an activity eventually
starts after a non-activity process launch.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix: Format adb test commands in TestBroadcastReceiver JavaDoc

Co-authored-by: Cursor <cursoragent@cursor.com>

* ref(android): Rename headless app start handling

Use headless terminology for app starts that do not reach an Activity and
schedule the headless check from lifecycle callback registration. This removes
listener setter side effects while preserving standalone app-start behavior.

Co-Authored-By: Claude <noreply@anthropic.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Align foreground app start measurements

Use the foreground app start fallback for foreground standalone app
start transactions so measurements match the transaction timestamp.
Keep the headless-only span source limited to true headless starts.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Gate headless app start end time

Resolve the headless app start end timestamp only when standalone
headless tracing is active. This avoids stopping legacy app start
spans before a later foreground Activity can finish them.

Co-authored-by: Cursor <cursoragent@cursor.com>

* test(android): Update API 35 headless app start expectation

Make the ApplicationStartInfo headless test install the listener that
now gates headless end-time resolution, matching the standalone path.

Co-authored-by: Cursor <cursoragent@cursor.com>

* Fix headless app-start idle scheduling

* ref(android): Clarify headless app start state names

Rename private headless app start flags to distinguish the pending
main-thread check from the one-shot listener invocation guard. No
behavior change.

Co-Authored-By: Claude <noreply@anthropic.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

* ref(android): Use app.start origin for headless app start transaction

Set the standalone headless app start transaction origin to
`auto.app.start` instead of `auto.ui.activity`, which was semantically
incorrect for non-activity (broadcast/service/content provider) starts.

Also simplify the API 35+ ApplicationStartInfo onCreate timestamp
resolution by using the reported nanos directly as the uptime base.

Co-authored-by: Cursor <cursoragent@cursor.com>

* ref(android): refine standalone app start trace continuation

Drop the redundant trace-id sharing TransactionContext constructor; the
ui.load now shares the app.start trace solely through continueTrace.

Don't connect a headless app.start and a following activity's ui.load into
the same trace when they are more than 1 minute apart, since such a large
gap means they no longer belong to the same launch.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): align headless app start tests with uptime-based onCreate timestamp

ApplicationStartInfo's START_TIMESTAMP_APPLICATION_ONCREATE is captured via
SystemClock.uptimeNanos(), the same base as TimeSpan, so no clock re-anchoring
is needed. Add the missing headless test setup (foreground-importance stubbing)
and fix the API 35 timestamp test to use uptime semantics.

Co-authored-by: Cursor <cursoragent@cursor.com>

* test(android): add standalone app start E2E harness

Wire the Android sample app for manual standalone app-start validation and add a reusable harness plus notes for the scenarios verified locally. Trim redundant comments around app-start trace continuation while keeping the non-obvious sampling and parentage details.

Co-Authored-By: Claude <noreply@anthropic.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

* chore(android): remove standalone app start report

Co-authored-by: Cursor <cursoragent@cursor.com>

* test(android): clarify app start transaction shapes

Co-authored-by: Cursor <cursoragent@cursor.com>

* chore(android): remove standalone app start harness

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Preserve app start activity counter

Keep the foreground headless guard from faking an observed activity so
late standalone app start init still lets the first real activity classify
startup and reset warm-start state correctly.

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(android): Finish app start after activity spans

Keep standalone app-start transactions open until activity lifecycle spans
are attached so early app-start completion does not drop activity spans.

Co-Authored-By: Cursor <cursoragent@cursor.com>

* feat(samples): enable standalone app start tracing and add headless-start broadcast receiver

Co-authored-by: Cursor <cursoragent@cursor.com>

* fix(changelog): resolve merge conflict and keep standalone app start entry under Unreleased

Co-authored-by: Cursor <cursoragent@cursor.com>

* docs(options): Clarify standalone app start javadoc per review

- Use plain quotes for the "App Start" transaction name instead of {@code}
- Clarify that the API 35 gate refers to the device's runtime OS version

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(android): Clarify ApplicationStartInfo onCreate timestamp marks onCreate start

START_TIMESTAMP_APPLICATION_ONCREATE is captured right before
Application.onCreate is invoked (ActivityThread.handleBindApplication),
so it is the onCreate start, not its end. Rename locals, fix comments
and javadoc accordingly, and drop the applicationOnCreate.setStoppedAt
branch which could have recorded a zero-length application.load span.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Cursor <cursoragent@cursor.com>
---
 CHANGELOG.md                                  |   8 +
 .../api/sentry-android-core.api               |  17 +
 .../core/ActivityLifecycleIntegration.java    | 293 +++++++--
 .../android/core/ManifestMetadataReader.java  |  10 +
 .../PerformanceAndroidEventProcessor.java     |  56 +-
 .../android/core/SentryAndroidOptions.java    |  49 ++
 .../core/performance/AppStartMetrics.java     | 209 ++++++-
 .../core/ActivityLifecycleIntegrationTest.kt  | 554 +++++++++++++++++-
 .../core/ManifestMetadataReaderTest.kt        |  30 +
 .../PerformanceAndroidEventProcessorTest.kt   | 183 +++++-
 .../android/core/SentryAndroidOptionsTest.kt  |   6 +
 .../core/SentryShadowActivityManager.kt       |  13 +
 .../android/core/SentryShadowProcess.kt       |  16 +-
 .../core/performance/AppStartMetricsTest.kt   | 195 +++++-
 .../performance/AppStartMetricsTestApi35.kt   | 130 ++++
 .../src/main/AndroidManifest.xml              |  13 +
 .../android/TestBroadcastReceiver.java        |  26 +
 17 files changed, 1695 insertions(+), 113 deletions(-)
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TestBroadcastReceiver.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9b42d4bd09d..cd876f3c57d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,14 @@
 
 ## Unreleased
 
+### Features
+
+- Add `enableStandaloneAppStartTracing` option to send app start as a standalone transaction instead of attaching it as a child span of the first activity transaction ([#5342](https://github.com/getsentry/sentry-java/pull/5342))
+  - Disabled by default; opt in via `options.isEnableStandaloneAppStartTracing = true` or manifest meta-data `io.sentry.standalone-app-start-tracing.enable`
+  - Emits a transaction named `App Start` with op `app.start`, carrying the existing app start measurements and phase spans (`process.load`, `contentprovider.load`, `application.load`, activity lifecycle spans) as direct children of the root
+  - The standalone transaction shares the same `traceId` as the first `ui.load` activity transaction so they remain linked in the trace view
+  - Also covers non-activity starts (broadcast receivers, services, content providers)
+
 ### Improvements
 
 - Reduce boxing to improve performance ([#5523](https://github.com/getsentry/sentry-java/pull/5523), [#5527](https://github.com/getsentry/sentry-java/pull/5527))
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 249549f8366..0500ba44990 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -392,6 +392,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun isEnablePerformanceV2 ()Z
 	public fun isEnableRootCheck ()Z
 	public fun isEnableScopeSync ()Z
+	public fun isEnableStandaloneAppStartTracing ()Z
 	public fun isEnableSystemEventBreadcrumbs ()Z
 	public fun isEnableSystemEventBreadcrumbsExtras ()Z
 	public fun isReportHistoricalAnrs ()Z
@@ -423,6 +424,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun setEnablePerformanceV2 (Z)V
 	public fun setEnableRootCheck (Z)V
 	public fun setEnableScopeSync (Z)V
+	public fun setEnableStandaloneAppStartTracing (Z)V
 	public fun setEnableSystemEventBreadcrumbs (Z)V
 	public fun setEnableSystemEventBreadcrumbsExtras (Z)V
 	public fun setFrameMetricsCollector (Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;)V
@@ -740,11 +742,16 @@ public class io/sentry/android/core/performance/AppStartMetrics : io/sentry/andr
 	public fun clear ()V
 	public fun createProcessInitSpan ()Lio/sentry/android/core/performance/TimeSpan;
 	public fun getActivityLifecycleTimeSpans ()Ljava/util/List;
+	public fun getAppStartBaggageHeader ()Ljava/lang/String;
 	public fun getAppStartContinuousProfiler ()Lio/sentry/IContinuousProfiler;
+	public fun getAppStartEndTime ()Lio/sentry/SentryDate;
 	public fun getAppStartProfiler ()Lio/sentry/ITransactionProfiler;
 	public fun getAppStartSamplingDecision ()Lio/sentry/TracesSamplingDecision;
+	public fun getAppStartSentryTraceHeader ()Ljava/lang/String;
 	public fun getAppStartTimeSpan ()Lio/sentry/android/core/performance/TimeSpan;
+	public fun getAppStartTimeSpanForHeadless ()Lio/sentry/android/core/performance/TimeSpan;
 	public fun getAppStartTimeSpanWithFallback (Lio/sentry/android/core/SentryAndroidOptions;)Lio/sentry/android/core/performance/TimeSpan;
+	public fun getAppStartTraceId ()Lio/sentry/protocol/SentryId;
 	public fun getAppStartType ()Lio/sentry/android/core/performance/AppStartMetrics$AppStartType;
 	public fun getApplicationOnCreateTimeSpan ()Lio/sentry/android/core/performance/TimeSpan;
 	public fun getClassLoadedUptimeMs ()J
@@ -765,12 +772,18 @@ public class io/sentry/android/core/performance/AppStartMetrics : io/sentry/andr
 	public static fun onContentProviderPostCreate (Landroid/content/ContentProvider;)V
 	public fun registerLifecycleCallbacks (Landroid/app/Application;)V
 	public fun setAppLaunchedInForeground (Z)V
+	public fun setAppStartBaggageHeader (Ljava/lang/String;)V
 	public fun setAppStartContinuousProfiler (Lio/sentry/IContinuousProfiler;)V
+	public fun setAppStartEndTime (Lio/sentry/SentryDate;)V
 	public fun setAppStartProfiler (Lio/sentry/ITransactionProfiler;)V
 	public fun setAppStartSamplingDecision (Lio/sentry/TracesSamplingDecision;)V
+	public fun setAppStartSentryTraceHeader (Ljava/lang/String;)V
+	public fun setAppStartTraceId (Lio/sentry/protocol/SentryId;)V
 	public fun setAppStartType (Lio/sentry/android/core/performance/AppStartMetrics$AppStartType;)V
 	public fun setClassLoadedUptimeMs (J)V
+	public fun setHeadlessAppStartListener (Lio/sentry/android/core/performance/AppStartMetrics$HeadlessAppStartListener;)V
 	public fun shouldSendStartMeasurements ()Z
+	public fun shouldSendStartMeasurements (Z)Z
 }
 
 public final class io/sentry/android/core/performance/AppStartMetrics$AppStartType : java/lang/Enum {
@@ -781,6 +794,10 @@ public final class io/sentry/android/core/performance/AppStartMetrics$AppStartTy
 	public static fun values ()[Lio/sentry/android/core/performance/AppStartMetrics$AppStartType;
 }
 
+public abstract interface class io/sentry/android/core/performance/AppStartMetrics$HeadlessAppStartListener {
+	public abstract fun onHeadlessAppStart ()V
+}
+
 public class io/sentry/android/core/performance/TimeSpan : java/lang/Comparable {
 	public fun <init> ()V
 	public fun compareTo (Lio/sentry/android/core/performance/TimeSpan;)I
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
index 9d748e5a27a..19cee7fcce5 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
@@ -9,6 +9,8 @@
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Looper;
+import io.sentry.Baggage;
+import io.sentry.BaggageHeader;
 import io.sentry.FullyDisplayedReporter;
 import io.sentry.IScope;
 import io.sentry.IScopes;
@@ -18,6 +20,7 @@
 import io.sentry.Instrumenter;
 import io.sentry.Integration;
 import io.sentry.NoOpTransaction;
+import io.sentry.PropagationContext;
 import io.sentry.SentryDate;
 import io.sentry.SentryLevel;
 import io.sentry.SentryNanotimeDate;
@@ -33,6 +36,7 @@
 import io.sentry.android.core.performance.AppStartMetrics;
 import io.sentry.android.core.performance.TimeSpan;
 import io.sentry.protocol.MeasurementValue;
+import io.sentry.protocol.SentryId;
 import io.sentry.protocol.TransactionNameSource;
 import io.sentry.util.AutoClosableReentrantLock;
 import io.sentry.util.Objects;
@@ -40,6 +44,7 @@
 import java.io.Closeable;
 import java.io.IOException;
 import java.lang.ref.WeakReference;
+import java.util.Collections;
 import java.util.Date;
 import java.util.Map;
 import java.util.WeakHashMap;
@@ -55,12 +60,19 @@ public final class ActivityLifecycleIntegration
     implements Integration, Closeable, Application.ActivityLifecycleCallbacks {
 
   static final String UI_LOAD_OP = "ui.load";
+  static final String STANDALONE_APP_START_OP = "app.start";
+  private static final String STANDALONE_APP_START_NAME = "App Start";
   static final String APP_START_WARM = "app.start.warm";
   static final String APP_START_COLD = "app.start.cold";
   static final String TTID_OP = "ui.load.initial_display";
   static final String TTFD_OP = "ui.load.full_display";
   static final long TTFD_TIMEOUT_MILLIS = 25000;
+  // If a headless app start and the following activity's ui.load are more than this far apart, they
+  // are treated as unrelated and not connected into the same trace.
+  static final long APP_START_TO_UI_LOAD_CONTINUATION_MAX_GAP_NANOS = TimeUnit.MINUTES.toNanos(1);
   private static final String TRACE_ORIGIN = "auto.ui.activity";
+  static final String APP_START_SCREEN_DATA = "app.vitals.start.screen";
+  static final String APP_START_TRACE_ORIGIN = "auto.app.start";
 
   private final @NotNull Application application;
   private final @NotNull BuildInfoProvider buildInfoProvider;
@@ -77,6 +89,7 @@ public final class ActivityLifecycleIntegration
 
   private @Nullable FullyDisplayedReporter fullyDisplayedReporter = null;
   private @Nullable ISpan appStartSpan;
+  private @Nullable ITransaction appStartTransaction;
   private final @NotNull WeakHashMap<Activity, ISpan> ttidSpanMap = new WeakHashMap<>();
   private final @NotNull WeakHashMap<Activity, ISpan> ttfdSpanMap = new WeakHashMap<>();
   private final @NotNull WeakHashMap<Activity, ActivityLifecycleSpanHelper> activitySpanHelpers =
@@ -124,6 +137,11 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
     timeToFullDisplaySpanEnabled = this.options.isEnableTimeToFullDisplayTracing();
 
     application.registerActivityLifecycleCallbacks(this);
+
+    if (performanceEnabled && this.options.isEnableStandaloneAppStartTracing()) {
+      AppStartMetrics.getInstance().setHeadlessAppStartListener(this::onHeadlessAppStart);
+    }
+
     this.options.getLogger().log(SentryLevel.DEBUG, "ActivityLifecycleIntegration installed.");
     addIntegrationToSdkVersion("ActivityLifecycle");
   }
@@ -135,6 +153,7 @@ private boolean isPerformanceEnabled(final @NotNull SentryAndroidOptions options
   @Override
   public void close() throws IOException {
     application.unregisterActivityLifecycleCallbacks(this);
+    AppStartMetrics.getInstance().setHeadlessAppStartListener(null);
 
     if (options != null) {
       options.getLogger().log(SentryLevel.DEBUG, "ActivityLifecycleIntegration removed.");
@@ -239,33 +258,93 @@ private void startTracing(final @NotNull Activity activity) {
         transactionOptions.setAppStartTransaction(appStartSamplingDecision != null);
         setSpanOrigin(transactionOptions);
 
-        // we can only bind to the scope if there's no running transaction
-        ITransaction transaction =
-            scopes.startTransaction(
-                new TransactionContext(
-                    activityName,
-                    TransactionNameSource.COMPONENT,
-                    UI_LOAD_OP,
-                    appStartSamplingDecision),
-                transactionOptions);
+        final @Nullable SentryId storedAppStartTraceId =
+            AppStartMetrics.getInstance().getAppStartTraceId();
+        final boolean isFollowingHeadlessAppStart = (storedAppStartTraceId != null);
+
+        final boolean isAppStart =
+            !(firstActivityCreated || appStartTime == null || coldStart == null);
+        // Foreground starts create app.start first; ui.load then shares its trace.
+        final boolean createStandaloneAppStart =
+            isAppStart
+                && options.isEnableStandaloneAppStartTracing()
+                && !isFollowingHeadlessAppStart;
+
+        if (createStandaloneAppStart) {
+          final TransactionOptions appStartTransactionOptions = new TransactionOptions();
+          appStartTransactionOptions.setBindToScope(false);
+          appStartTransactionOptions.setStartTimestamp(appStartTime);
+          appStartTransactionOptions.setAppStartTransaction(appStartSamplingDecision != null);
+          appStartTransactionOptions.setOrigin(APP_START_TRACE_ORIGIN);
+
+          appStartTransaction =
+              scopes.startTransaction(
+                  new TransactionContext(
+                      STANDALONE_APP_START_NAME,
+                      TransactionNameSource.COMPONENT,
+                      STANDALONE_APP_START_OP,
+                      appStartSamplingDecision),
+                  appStartTransactionOptions);
+          appStartTransaction.setData(APP_START_SCREEN_DATA, activityName);
+        }
+
+        // Continue either the foreground app.start above or an earlier headless app.start.
+        final @Nullable String continueSentryTrace;
+        final @Nullable String continueBaggage;
+        if (createStandaloneAppStart) {
+          continueSentryTrace = appStartTransaction.toSentryTrace().getValue();
+          final @Nullable BaggageHeader baggageHeader = appStartTransaction.toBaggageHeader(null);
+          continueBaggage = baggageHeader == null ? null : baggageHeader.getValue();
+        } else if (isFollowingHeadlessAppStart
+            && isWithinAppStartContinuationWindow(ttidStartTime)) {
+          continueSentryTrace = AppStartMetrics.getInstance().getAppStartSentryTraceHeader();
+          continueBaggage = AppStartMetrics.getInstance().getAppStartBaggageHeader();
+        } else {
+          continueSentryTrace = null;
+          continueBaggage = null;
+        }
+
+        final @Nullable TransactionContext continuedContext =
+            continueSentryTrace == null
+                ? null
+                : continueUiLoadTrace(continueSentryTrace, continueBaggage, activityName);
+
+        final ITransaction transaction;
+        if (continuedContext != null) {
+          transaction = scopes.startTransaction(continuedContext, transactionOptions);
+        } else {
+          transaction =
+              scopes.startTransaction(
+                  new TransactionContext(
+                      activityName,
+                      TransactionNameSource.COMPONENT,
+                      UI_LOAD_OP,
+                      appStartSamplingDecision),
+                  transactionOptions);
+        }
+
+        if (isFollowingHeadlessAppStart) {
+          // Consume the stored headless app-start trace so it isn't reused by another activity.
+          AppStartMetrics.getInstance().setAppStartTraceId(null);
+          AppStartMetrics.getInstance().setAppStartSentryTraceHeader(null);
+          AppStartMetrics.getInstance().setAppStartBaggageHeader(null);
+        }
 
         final SpanOptions spanOptions = new SpanOptions();
         setSpanOrigin(spanOptions);
 
-        // in case appStartTime isn't available, we don't create a span for it.
-        if (!(firstActivityCreated || appStartTime == null || coldStart == null)) {
-          // start specific span for app start
-          appStartSpan =
-              transaction.startChild(
-                  getAppStartOp(coldStart),
-                  getAppStartDesc(coldStart),
-                  appStartTime,
-                  Instrumenter.SENTRY,
-                  spanOptions);
-
-          // in case there's already an end time (e.g. due to deferred SDK init)
-          // we can finish the app-start span
-          finishAppStartSpan();
+        if (isAppStart) {
+          if (!createStandaloneAppStart && !options.isEnableStandaloneAppStartTracing()) {
+            appStartSpan =
+                transaction.startChild(
+                    getAppStartOp(coldStart),
+                    getAppStartDesc(coldStart),
+                    appStartTime,
+                    Instrumenter.SENTRY,
+                    spanOptions);
+
+            finishAppStartSpan();
+          }
         }
         final @NotNull ISpan ttidSpan =
             transaction.startChild(
@@ -316,6 +395,61 @@ private void setSpanOrigin(final @NotNull SpanOptions spanOptions) {
     spanOptions.setOrigin(TRACE_ORIGIN);
   }
 
+  /**
+   * Whether the ui.load starting at {@code uiLoadStartTime} is close enough in time to the headless
+   * app start to belong to the same trace. If they are more than {@link
+   * #APP_START_TO_UI_LOAD_CONTINUATION_MAX_GAP_NANOS} apart, they are treated as unrelated. When
+   * the headless end time is unknown, we keep the previous behaviour and continue the trace.
+   */
+  private boolean isWithinAppStartContinuationWindow(final @NotNull SentryDate uiLoadStartTime) {
+    final @Nullable SentryDate appStartEndTime = AppStartMetrics.getInstance().getAppStartEndTime();
+    if (appStartEndTime == null) {
+      return true;
+    }
+    return uiLoadStartTime.diff(appStartEndTime) <= APP_START_TO_UI_LOAD_CONTINUATION_MAX_GAP_NANOS;
+  }
+
+  /**
+   * Builds a {@link TransactionContext} for the ui.load transaction that shares the standalone
+   * app.start trace (same traceId and sampleRand) while staying a sibling (no parentSpanId), rather
+   * than a child. The continued baggage keeps sampling decisions on the same sampleRand. Returns
+   * null if the trace cannot be continued, so callers can fall back.
+   */
+  private @Nullable TransactionContext continueUiLoadTrace(
+      final @NotNull String sentryTrace,
+      final @Nullable String baggage,
+      final @NotNull String activityName) {
+    if (options == null || !options.isTracingEnabled()) {
+      return null;
+    }
+    final @NotNull PropagationContext propagationContext =
+        PropagationContext.fromHeaders(
+            options.getLogger(),
+            sentryTrace,
+            baggage == null ? null : Collections.singletonList(baggage),
+            options);
+    final @Nullable Boolean parentSampled = propagationContext.isSampled();
+    final @NotNull Baggage continuedBaggage = propagationContext.getBaggage();
+    final @Nullable TracesSamplingDecision parentSamplingDecision =
+        parentSampled == null
+            ? null
+            : new TracesSamplingDecision(
+                parentSampled,
+                continuedBaggage.getSampleRate(),
+                propagationContext.getSampleRand());
+    final @NotNull TransactionContext context =
+        new TransactionContext(
+            propagationContext.getTraceId(),
+            propagationContext.getSpanId(),
+            null,
+            parentSamplingDecision,
+            continuedBaggage);
+    context.setName(activityName);
+    context.setTransactionNameSource(TransactionNameSource.COMPONENT);
+    context.setOperation(UI_LOAD_OP);
+    return context;
+  }
+
   @VisibleForTesting
   void applyScope(final @NotNull IScope scope, final @NotNull ITransaction transaction) {
     scope.withTransaction(
@@ -440,8 +574,7 @@ public void onActivityPostCreated(
       final @NotNull Activity activity, final @Nullable Bundle savedInstanceState) {
     final ActivityLifecycleSpanHelper helper = activitySpanHelpers.get(activity);
     if (helper != null) {
-      helper.createAndStopOnCreateSpan(
-          appStartSpan != null ? appStartSpan : activitiesWithOngoingTransactions.get(activity));
+      helper.createAndStopOnCreateSpan(getAppStartParent(activity));
     }
   }
 
@@ -479,11 +612,11 @@ public void onActivityStarted(final @NotNull Activity activity) {
   public void onActivityPostStarted(final @NotNull Activity activity) {
     final ActivityLifecycleSpanHelper helper = activitySpanHelpers.get(activity);
     if (helper != null) {
-      helper.createAndStopOnStartSpan(
-          appStartSpan != null ? appStartSpan : activitiesWithOngoingTransactions.get(activity));
+      helper.createAndStopOnStartSpan(getAppStartParent(activity));
       // Needed to handle hybrid SDKs
       helper.saveSpanToAppStartMetrics();
     }
+    finishAppStartSpan();
   }
 
   @Override
@@ -559,6 +692,9 @@ public void onActivityDestroyed(final @NotNull Activity activity) {
         // in case the appStartSpan isn't completed yet, we finish it as cancelled to avoid
         // memory leak
         finishSpan(appStartSpan, SpanStatus.CANCELLED);
+        if (appStartTransaction != null && !appStartTransaction.isFinished()) {
+          appStartTransaction.finish(SpanStatus.CANCELLED);
+        }
 
         // we finish the ttidSpan as cancelled in case it isn't completed yet
         final ISpan ttidSpan = ttidSpanMap.get(activity);
@@ -575,6 +711,7 @@ public void onActivityDestroyed(final @NotNull Activity activity) {
 
         // set it to null in case its been just finished as cancelled
         appStartSpan = null;
+        appStartTransaction = null;
         ttidSpanMap.remove(activity);
         ttfdSpanMap.remove(activity);
       }
@@ -637,22 +774,23 @@ private void onFirstFrameDrawn(final @Nullable ISpan ttfdSpan, final @Nullable I
     final @NotNull AppStartMetrics appStartMetrics = AppStartMetrics.getInstance();
     final @NotNull TimeSpan appStartTimeSpan = appStartMetrics.getAppStartTimeSpan();
     final @NotNull TimeSpan sdkInitTimeSpan = appStartMetrics.getSdkInitTimeSpan();
+    final @Nullable SentryDate firstFrameEndDate =
+        options != null ? options.getDateProvider().now() : null;
 
     // and we need to set the end time of the app start here, after the first frame is drawn.
     if (appStartTimeSpan.hasStarted() && appStartTimeSpan.hasNotStopped()) {
-      appStartTimeSpan.stop();
+      stopTimeSpanAtDate(appStartTimeSpan, firstFrameEndDate);
     }
     if (sdkInitTimeSpan.hasStarted() && sdkInitTimeSpan.hasNotStopped()) {
-      sdkInitTimeSpan.stop();
+      stopTimeSpanAtDate(sdkInitTimeSpan, firstFrameEndDate);
     }
-    finishAppStartSpan();
+    finishAppStartSpan(firstFrameEndDate);
 
     // Sentry.reportFullyDisplayed can be run in any thread, so we have to ensure synchronization
     // with first frame drawn
     try (final @NotNull ISentryLifecycleToken ignored = fullyDisplayedLock.acquire()) {
-      if (options != null && ttidSpan != null) {
-        final SentryDate endDate = options.getDateProvider().now();
-        final long durationNanos = endDate.diff(ttidSpan.getStartDate());
+      if (options != null && ttidSpan != null && firstFrameEndDate != null) {
+        final long durationNanos = firstFrameEndDate.diff(ttidSpan.getStartDate());
         final long durationMillis = TimeUnit.NANOSECONDS.toMillis(durationNanos);
         ttidSpan.setMeasurement(
             MeasurementValue.KEY_TIME_TO_INITIAL_DISPLAY, durationMillis, MILLISECOND);
@@ -664,10 +802,10 @@ private void onFirstFrameDrawn(final @Nullable ISpan ttfdSpan, final @Nullable I
               MeasurementValue.KEY_TIME_TO_FULL_DISPLAY, durationMillis, MILLISECOND);
           ttfdSpan.setMeasurement(
               MeasurementValue.KEY_TIME_TO_FULL_DISPLAY, durationMillis, MILLISECOND);
-          finishSpan(ttfdSpan, endDate);
+          finishSpan(ttfdSpan, firstFrameEndDate);
         }
 
-        finishSpan(ttidSpan, endDate);
+        finishSpan(ttidSpan, firstFrameEndDate);
       } else {
         finishSpan(ttidSpan);
         if (fullyDisplayedCalled) {
@@ -677,6 +815,17 @@ private void onFirstFrameDrawn(final @Nullable ISpan ttfdSpan, final @Nullable I
     }
   }
 
+  private void stopTimeSpanAtDate(
+      final @NotNull TimeSpan timeSpan, final @Nullable SentryDate endDate) {
+    final @Nullable SentryDate startDate = timeSpan.getStartTimestamp();
+    if (endDate != null && startDate != null) {
+      final long durationMillis = TimeUnit.NANOSECONDS.toMillis(endDate.diff(startDate));
+      timeSpan.setStoppedAt(timeSpan.getStartUptimeMs() + durationMillis);
+    } else {
+      timeSpan.stop();
+    }
+  }
+
   private void onFullFrameDrawn(final @NotNull ISpan ttidSpan, final @NotNull ISpan ttfdSpan) {
     cancelTtfdAutoClose();
     // Sentry.reportFullyDisplayed can be run in any thread, so we have to ensure synchronization
@@ -779,6 +928,16 @@ WeakHashMap<Activity, ISpan> getTtfdSpanMap() {
     }
   }
 
+  private @Nullable ISpan getAppStartParent(final @NotNull Activity activity) {
+    if (appStartTransaction != null) {
+      return appStartTransaction;
+    }
+    if (appStartSpan != null) {
+      return appStartSpan;
+    }
+    return activitiesWithOngoingTransactions.get(activity);
+  }
+
   private @NotNull String getAppStartOp(final boolean coldStart) {
     if (coldStart) {
       return APP_START_COLD;
@@ -788,12 +947,70 @@ WeakHashMap<Activity, ISpan> getTtfdSpanMap() {
   }
 
   private void finishAppStartSpan() {
+    finishAppStartSpan(null);
+  }
+
+  private void finishAppStartSpan(final @Nullable SentryDate endDate) {
     final @Nullable SentryDate appStartEndTime =
-        AppStartMetrics.getInstance()
-            .getAppStartTimeSpanWithFallback(options)
-            .getProjectedStopTimestamp();
+        endDate != null
+            ? endDate
+            : AppStartMetrics.getInstance()
+                .getAppStartTimeSpanWithFallback(options)
+                .getProjectedStopTimestamp();
     if (performanceEnabled && appStartEndTime != null) {
       finishSpan(appStartSpan, appStartEndTime);
+      if (appStartTransaction != null && !appStartTransaction.isFinished()) {
+        appStartTransaction.finish(SpanStatus.OK, appStartEndTime);
+      }
     }
   }
+
+  private void onHeadlessAppStart() {
+    if (scopes == null || options == null || !performanceEnabled) {
+      return;
+    }
+
+    final @NotNull AppStartMetrics metrics = AppStartMetrics.getInstance();
+    // Profilers are stopped for headless starts; clear the decision so it doesn't
+    // leak to a later ui.load transaction if an activity eventually opens.
+    metrics.setAppStartSamplingDecision(null);
+
+    // For headless starts, appLaunchedInForeground is false, so we can't use
+    // getAppStartTimeSpanWithFallback (which gates on foreground).
+    final @NotNull TimeSpan appStartTimeSpan = metrics.getAppStartTimeSpanForHeadless();
+
+    if (!appStartTimeSpan.hasStarted() || !appStartTimeSpan.hasStopped()) {
+      return;
+    }
+
+    final @Nullable SentryDate startTime = appStartTimeSpan.getStartTimestamp();
+    final @Nullable SentryDate endTime = appStartTimeSpan.getProjectedStopTimestamp();
+    if (startTime == null || endTime == null) {
+      return;
+    }
+
+    final TransactionOptions txnOptions = new TransactionOptions();
+    txnOptions.setBindToScope(false);
+    txnOptions.setStartTimestamp(startTime);
+    txnOptions.setOrigin(APP_START_TRACE_ORIGIN);
+
+    final @NotNull TransactionContext txnContext =
+        new TransactionContext(
+            STANDALONE_APP_START_NAME,
+            TransactionNameSource.COMPONENT,
+            STANDALONE_APP_START_OP,
+            null);
+
+    final @NotNull ITransaction transaction = scopes.startTransaction(txnContext, txnOptions);
+    metrics.setAppStartTraceId(transaction.getSpanContext().getTraceId());
+    // Persist trace headers so a later ui.load can share traceId and sampleRand.
+    metrics.setAppStartSentryTraceHeader(transaction.toSentryTrace().getValue());
+    final @Nullable BaggageHeader baggageHeader = transaction.toBaggageHeader(null);
+    metrics.setAppStartBaggageHeader(baggageHeader == null ? null : baggageHeader.getValue());
+    // Persist the end time so a later activity can decide whether its ui.load is close enough in
+    // time to continue this trace.
+    metrics.setAppStartEndTime(endTime);
+
+    transaction.finish(SpanStatus.OK, endTime);
+  }
 }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index e16d4b312fc..c34ee0dbfa9 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -108,6 +108,9 @@ final class ManifestMetadataReader {
 
   static final String ENABLE_PERFORMANCE_V2 = "io.sentry.performance-v2.enable";
 
+  static final String ENABLE_STANDALONE_APP_START_TRACING =
+      "io.sentry.standalone-app-start-tracing.enable";
+
   static final String ENABLE_APP_START_PROFILING = "io.sentry.profiling.enable-app-start";
 
   static final String ENABLE_SCOPE_PERSISTENCE = "io.sentry.enable-scope-persistence";
@@ -502,6 +505,13 @@ static void applyMetadata(
         options.setEnablePerformanceV2(
             readBool(metadata, logger, ENABLE_PERFORMANCE_V2, options.isEnablePerformanceV2()));
 
+        options.setEnableStandaloneAppStartTracing(
+            readBool(
+                metadata,
+                logger,
+                ENABLE_STANDALONE_APP_START_TRACING,
+                options.isEnableStandaloneAppStartTracing()));
+
         options.setEnableAppStartProfiling(
             readBool(
                 metadata, logger, ENABLE_APP_START_PROFILING, options.isEnableAppStartProfiling()));
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java
index f7b51cce620..0b50b5080f4 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java
@@ -1,7 +1,9 @@
 package io.sentry.android.core;
 
 import static io.sentry.android.core.ActivityLifecycleIntegration.APP_START_COLD;
+import static io.sentry.android.core.ActivityLifecycleIntegration.APP_START_SCREEN_DATA;
 import static io.sentry.android.core.ActivityLifecycleIntegration.APP_START_WARM;
+import static io.sentry.android.core.ActivityLifecycleIntegration.STANDALONE_APP_START_OP;
 import static io.sentry.android.core.ActivityLifecycleIntegration.UI_LOAD_OP;
 
 import io.sentry.EventProcessor;
@@ -84,9 +86,21 @@ public SentryEvent process(@NotNull SentryEvent event, @NotNull Hint hint) {
       // the app start measurement is only sent once and only if the transaction has
       // the app.start span, which is automatically created by the SDK.
       if (hasAppStartSpan(transaction)) {
-        if (appStartMetrics.shouldSendStartMeasurements()) {
+        // For headless starts, appLaunchedInForeground is false, so only headless standalone app
+        // start transactions bypass the foreground check, not the duplicate-send guard.
+        final @Nullable SpanContext traceContext = transaction.getContexts().getTrace();
+        final boolean isStandaloneAppStartTxn =
+            traceContext != null && STANDALONE_APP_START_OP.equals(traceContext.getOperation());
+        final boolean isHeadlessStandaloneAppStartTxn =
+            traceContext != null
+                && isStandaloneAppStartTxn
+                && !traceContext.getData().containsKey(APP_START_SCREEN_DATA);
+
+        if (appStartMetrics.shouldSendStartMeasurements(isHeadlessStandaloneAppStartTxn)) {
           final @NotNull TimeSpan appStartTimeSpan =
-              appStartMetrics.getAppStartTimeSpanWithFallback(options);
+              isHeadlessStandaloneAppStartTxn
+                  ? appStartMetrics.getAppStartTimeSpanForHeadless()
+                  : appStartMetrics.getAppStartTimeSpanWithFallback(options);
           final long appStartUpDurationMs = appStartTimeSpan.getDurationMs();
 
           // if appStartUpDurationMs is 0, metrics are not ready to be sent
@@ -216,9 +230,7 @@ private boolean hasAppStartSpan(final @NotNull SentryTransaction txn) {
     }
 
     final @Nullable SpanContext context = txn.getContexts().getTrace();
-    return context != null
-        && (context.getOperation().equals(APP_START_COLD)
-            || context.getOperation().equals(APP_START_WARM));
+    return context != null && context.getOperation().equals(STANDALONE_APP_START_OP);
   }
 
   private void attachAppStartSpans(
@@ -245,6 +257,16 @@ private void attachAppStartSpans(
       }
     }
 
+    // For standalone app start transactions, the transaction root IS the app start span
+    if (parentSpanId == null) {
+      final @NotNull String txnOp = traceContext.getOperation();
+      if (STANDALONE_APP_START_OP.equals(txnOp)) {
+        parentSpanId = traceContext.getSpanId();
+      }
+    }
+
+    final boolean isStandalone = STANDALONE_APP_START_OP.equals(traceContext.getOperation());
+
     // Process init
     final @NotNull TimeSpan processInitTimeSpan = appStartMetrics.createProcessInitSpan();
     if (processInitTimeSpan.hasStarted()
@@ -252,7 +274,11 @@ private void attachAppStartSpans(
       txn.getSpans()
           .add(
               timeSpanToSentrySpan(
-                  processInitTimeSpan, parentSpanId, traceId, APP_METRICS_PROCESS_INIT_OP));
+                  processInitTimeSpan,
+                  parentSpanId,
+                  traceId,
+                  APP_METRICS_PROCESS_INIT_OP,
+                  isStandalone));
     }
 
     // Content Providers
@@ -263,7 +289,11 @@ private void attachAppStartSpans(
         txn.getSpans()
             .add(
                 timeSpanToSentrySpan(
-                    contentProvider, parentSpanId, traceId, APP_METRICS_CONTENT_PROVIDER_OP));
+                    contentProvider,
+                    parentSpanId,
+                    traceId,
+                    APP_METRICS_CONTENT_PROVIDER_OP,
+                    isStandalone));
       }
     }
 
@@ -272,7 +302,8 @@ private void attachAppStartSpans(
     if (appOnCreate.hasStopped()) {
       txn.getSpans()
           .add(
-              timeSpanToSentrySpan(appOnCreate, parentSpanId, traceId, APP_METRICS_APPLICATION_OP));
+              timeSpanToSentrySpan(
+                  appOnCreate, parentSpanId, traceId, APP_METRICS_APPLICATION_OP, isStandalone));
     }
   }
 
@@ -281,14 +312,17 @@ private static SentrySpan timeSpanToSentrySpan(
       final @NotNull TimeSpan span,
       final @Nullable SpanId parentSpanId,
       final @NotNull SentryId traceId,
-      final @NotNull String operation) {
+      final @NotNull String operation,
+      final boolean isStandaloneAppStart) {
 
     final Map<String, Object> defaultSpanData = new HashMap<>(2);
     defaultSpanData.put(SpanDataConvention.THREAD_ID, AndroidThreadChecker.mainThreadSystemId);
     defaultSpanData.put(SpanDataConvention.THREAD_NAME, "main");
 
-    defaultSpanData.put(SpanDataConvention.CONTRIBUTES_TTID, true);
-    defaultSpanData.put(SpanDataConvention.CONTRIBUTES_TTFD, true);
+    if (!isStandaloneAppStart) {
+      defaultSpanData.put(SpanDataConvention.CONTRIBUTES_TTID, true);
+      defaultSpanData.put(SpanDataConvention.CONTRIBUTES_TTFD, true);
+    }
 
     return new SentrySpan(
         span.getStartTimestampSecs(),
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
index bb9ec17aabd..ed07c4edaaf 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
@@ -246,6 +246,8 @@ public interface BeforeCaptureCallback {
 
   private boolean enablePerformanceV2 = true;
 
+  private boolean enableStandaloneAppStartTracing = false;
+
   private @Nullable SentryFrameMetricsCollector frameMetricsCollector;
 
   private boolean enableTombstone = false;
@@ -677,6 +679,53 @@ public void setEnablePerformanceV2(final boolean enablePerformanceV2) {
     this.enablePerformanceV2 = enablePerformanceV2;
   }
 
+  /**
+   * @return true if standalone app start tracing is enabled. See {@link
+   *     #setEnableStandaloneAppStartTracing(boolean)} for more details.
+   */
+  @ApiStatus.Experimental
+  public boolean isEnableStandaloneAppStartTracing() {
+    return enableStandaloneAppStartTracing;
+  }
+
+  /**
+   * Enables or disables standalone app start tracing.
+   *
+   * <p>When enabled, app start is sent as its own transaction instead of an {@code app.start.*}
+   * child span on the first Activity transaction.
+   *
+   * <p>The SDK reports app start through these paths:
+   *
+   * <ul>
+   *   <li>With an Activity: the SDK sends an "App Start" transaction with operation {@code
+   *       app.start}, plus a separate {@code ui.load} transaction for the Activity. Both
+   *       transactions share the same trace ID.
+   *   <li>Headless app start: for launches started by something like a broadcast receiver, service,
+   *       or content provider without an Activity, the SDK sends only the standalone app-start
+   *       transaction.
+   *       <ul>
+   *         <li>On devices running Android 15 (API level 35) or newer, the SDK can use {@code
+   *             ApplicationStartInfo} to classify cold versus warm starts and anchor the end time
+   *             at the {@code Application.onCreate} start.
+   *         <li>On devices running older Android versions, headless launches are treated as cold
+   *             once {@code Application.onCreate} finishes without an Activity. The end time falls
+   *             back to the best SDK/plugin timing available.
+   *         <li>With {@code Application.onCreate} instrumentation, the SDK can add an {@code
+   *             application.load} phase span and use the exact {@code Application.onCreate} end
+   *             time. Without that instrumentation, the standalone transaction is still sent, but
+   *             it may only include the {@code process.load} phase span.
+   *       </ul>
+   *   <li>If an Activity opens after a headless start, its {@code ui.load} transaction reuses the
+   *       app-start trace ID.
+   * </ul>
+   *
+   * @param enableStandaloneAppStartTracing true if enabled or false otherwise
+   */
+  @ApiStatus.Experimental
+  public void setEnableStandaloneAppStartTracing(final boolean enableStandaloneAppStartTracing) {
+    this.enableStandaloneAppStartTracing = enableStandaloneAppStartTracing;
+  }
+
   @ApiStatus.Internal
   public @Nullable SentryFrameMetricsCollector getFrameMetricsCollector() {
     return frameMetricsCollector;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
index 746805fcfdc..d8cb0827ba4 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
@@ -10,7 +10,6 @@
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Looper;
-import android.os.MessageQueue;
 import android.os.SystemClock;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -19,12 +18,14 @@
 import io.sentry.ISentryLifecycleToken;
 import io.sentry.ITransactionProfiler;
 import io.sentry.NoOpLogger;
+import io.sentry.SentryDate;
 import io.sentry.TracesSamplingDecision;
 import io.sentry.android.core.BuildInfoProvider;
 import io.sentry.android.core.ContextUtils;
 import io.sentry.android.core.CurrentActivityHolder;
 import io.sentry.android.core.SentryAndroidOptions;
 import io.sentry.android.core.internal.util.FirstDrawDoneListener;
+import io.sentry.protocol.SentryId;
 import io.sentry.util.AutoClosableReentrantLock;
 import io.sentry.util.LazyEvaluator;
 import java.util.ArrayList;
@@ -49,6 +50,10 @@
  */
 @ApiStatus.Internal
 public class AppStartMetrics extends ActivityLifecycleCallbacksAdapter {
+  public interface HeadlessAppStartListener {
+    void onHeadlessAppStart();
+  }
+
   public enum AppStartType {
     UNKNOWN,
     COLD,
@@ -84,6 +89,15 @@ public enum AppStartType {
   private boolean shouldSendStartMeasurements = true;
   private final AtomicInteger activeActivitiesCounter = new AtomicInteger();
   private final AtomicBoolean firstDrawDone = new AtomicBoolean(false);
+  private final AtomicBoolean headlessAppStartCheckPending = new AtomicBoolean(false);
+  private final AtomicBoolean headlessAppStartListenerInvoked = new AtomicBoolean(false);
+  private volatile @Nullable HeadlessAppStartListener headlessAppStartListener;
+  // Captures a headless app.start so a later ui.load can share its trace.
+  private @Nullable SentryId appStartTraceId;
+  private @Nullable String appStartSentryTraceHeader;
+  private @Nullable String appStartBaggageHeader;
+  private @Nullable SentryDate appStartEndTime;
+  private @Nullable ApplicationStartInfo cachedStartInfo;
 
   public static @NotNull AppStartMetrics getInstance() {
     if (instance == null) {
@@ -161,6 +175,48 @@ public void setAppLaunchedInForeground(final boolean appLaunchedInForeground) {
     this.appLaunchedInForeground.setValue(appLaunchedInForeground);
   }
 
+  public void setHeadlessAppStartListener(final @Nullable HeadlessAppStartListener listener) {
+    this.headlessAppStartListener = listener;
+    if (listener != null
+        && isCallbackRegistered
+        && activeActivitiesCounter.get() == 0
+        && !firstDrawDone.get()) {
+      scheduleHeadlessAppStartCheckOnMain();
+    }
+  }
+
+  public @Nullable SentryId getAppStartTraceId() {
+    return appStartTraceId;
+  }
+
+  public void setAppStartTraceId(final @Nullable SentryId traceId) {
+    this.appStartTraceId = traceId;
+  }
+
+  public @Nullable String getAppStartSentryTraceHeader() {
+    return appStartSentryTraceHeader;
+  }
+
+  public void setAppStartSentryTraceHeader(final @Nullable String appStartSentryTraceHeader) {
+    this.appStartSentryTraceHeader = appStartSentryTraceHeader;
+  }
+
+  public @Nullable String getAppStartBaggageHeader() {
+    return appStartBaggageHeader;
+  }
+
+  public void setAppStartBaggageHeader(final @Nullable String appStartBaggageHeader) {
+    this.appStartBaggageHeader = appStartBaggageHeader;
+  }
+
+  public @Nullable SentryDate getAppStartEndTime() {
+    return appStartEndTime;
+  }
+
+  public void setAppStartEndTime(final @Nullable SentryDate appStartEndTime) {
+    this.appStartEndTime = appStartEndTime;
+  }
+
   /**
    * Provides all collected content provider onCreate time spans
    *
@@ -188,14 +244,30 @@ public void onAppStartSpansSent() {
     activityLifecycles.clear();
   }
 
+  public boolean shouldSendStartMeasurements(final boolean ignoreForegroundCheck) {
+    return shouldSendStartMeasurements
+        && (ignoreForegroundCheck || appLaunchedInForeground.getValue());
+  }
+
   public boolean shouldSendStartMeasurements() {
-    return shouldSendStartMeasurements && appLaunchedInForeground.getValue();
+    return shouldSendStartMeasurements(false);
   }
 
   public long getClassLoadedUptimeMs() {
     return CLASS_LOADED_UPTIME_MS;
   }
 
+  /**
+   * Returns a valid app start time span, bypassing the foreground check. Tries appStartSpan first,
+   * falls back to sdkInitTimeSpan. Used for headless starts where appLaunchedInForeground is false.
+   */
+  public @NotNull TimeSpan getAppStartTimeSpanForHeadless() {
+    if (appStartSpan.hasStarted() && appStartSpan.hasStopped()) {
+      return appStartSpan;
+    }
+    return sdkInitTimeSpan;
+  }
+
   /**
    * @return the app start time span if it was started and perf-2 is enabled, falls back to the sdk
    *     init time span otherwise
@@ -258,6 +330,14 @@ public void clear() {
     firstDrawDone.set(false);
     activeActivitiesCounter.set(0);
     firstIdle = -1;
+    headlessAppStartCheckPending.set(false);
+    headlessAppStartListenerInvoked.set(false);
+    headlessAppStartListener = null;
+    appStartTraceId = null;
+    appStartSentryTraceHeader = null;
+    appStartBaggageHeader = null;
+    appStartEndTime = null;
+    cachedStartInfo = null;
   }
 
   public @Nullable ITransactionProfiler getAppStartProfiler() {
@@ -346,6 +426,7 @@ public void registerLifecycleCallbacks(final @NotNull Application application) {
             activityManager.getHistoricalProcessStartReasons(1);
         if (!historicalProcessStartReasons.isEmpty()) {
           final @NotNull ApplicationStartInfo info = historicalProcessStartReasons.get(0);
+          cachedStartInfo = info;
           if (info.getStartupState() == ApplicationStartInfo.STARTUP_STATE_STARTED) {
             if (info.getStartType() == ApplicationStartInfo.START_TYPE_COLD) {
               appStartType = AppStartType.COLD;
@@ -357,41 +438,61 @@ public void registerLifecycleCallbacks(final @NotNull Application application) {
       }
     }
 
-    if (appStartType == AppStartType.UNKNOWN && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+    if (appStartType == AppStartType.UNKNOWN || headlessAppStartListener != null) {
+      scheduleHeadlessAppStartCheckOnMain();
+    }
+  }
+
+  private void scheduleHeadlessAppStartCheckOnMain() {
+    if (!headlessAppStartCheckPending.compareAndSet(false, true)) {
+      return;
+    }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
       Looper.getMainLooper()
           .getQueue()
           .addIdleHandler(
-              new MessageQueue.IdleHandler() {
-                @Override
-                public boolean queueIdle() {
-                  firstIdle = SystemClock.uptimeMillis();
-                  checkCreateTimeOnMain();
-                  return false;
-                }
+              () -> {
+                firstIdle = SystemClock.uptimeMillis();
+                headlessAppStartCheckPending.set(false);
+                handleHeadlessAppStartIfNeededOnMain();
+                return false;
               });
-    } else if (appStartType == AppStartType.UNKNOWN) {
-      // We post on the main thread a task to post a check on the main thread. On Pixel devices
-      // (possibly others) the first task posted on the main thread is called before the
-      // Activity.onCreate callback. This is a workaround for that, so that the Activity.onCreate
-      // callback is called before the application one.
+    } else {
       final Handler handler = new Handler(Looper.getMainLooper());
       handler.post(
-          new Runnable() {
-            @Override
-            public void run() {
-              // not technically correct, but close enough for pre-M
-              firstIdle = SystemClock.uptimeMillis();
-              handler.post(() -> checkCreateTimeOnMain());
-            }
+          () -> {
+            firstIdle = SystemClock.uptimeMillis();
+            handler.post(
+                () -> {
+                  headlessAppStartCheckPending.set(false);
+                  handleHeadlessAppStartIfNeededOnMain();
+                });
           });
     }
   }
 
-  private void checkCreateTimeOnMain() {
-    // if no activity has ever been created, app was launched in background
+  /**
+   * Checks whether startup reached an Activity after the main looper had a chance to create one. If
+   * not, handles the headless app start path. Must be called on the main thread.
+   */
+  private void handleHeadlessAppStartIfNeededOnMain() {
     if (activeActivitiesCounter.get() == 0) {
+      // SDK init happened after Application.onCreate (e.g. deferred/late init inside an Activity):
+      // we missed the Activity's onActivityCreated, but a foreground process means it was a real
+      // launch, not a headless start. Gated on the listener so only the standalone-app-start path
+      // (which is what could emit a headless transaction) is affected.
+      if (headlessAppStartListener != null && ContextUtils.isForegroundImportance()) {
+        return;
+      }
+
       appLaunchedInForeground.setValue(false);
 
+      // Headless starts have no Activity signal for the pre-API 35 warm/cold heuristic.
+      // If ApplicationStartInfo did not resolve the type, classify the process start as cold.
+      if (appStartType == AppStartType.UNKNOWN) {
+        appStartType = AppStartType.COLD;
+      }
+
       // we stop the app start profilers, as they are useless and likely to timeout
       if (appStartProfiler != null && appStartProfiler.isRunning()) {
         appStartProfiler.close();
@@ -401,6 +502,56 @@ private void checkCreateTimeOnMain() {
         appStartContinuousProfiler.close(true);
         appStartContinuousProfiler = null;
       }
+
+      final @Nullable HeadlessAppStartListener listener = headlessAppStartListener;
+      if (listener != null && headlessAppStartListenerInvoked.compareAndSet(false, true)) {
+        resolveHeadlessAppStartEndTime();
+        listener.onHeadlessAppStart();
+      }
+    }
+  }
+
+  private void resolveHeadlessAppStartEndTime() {
+    // Priority 1: Gradle plugin instrumented onApplicationPostCreate
+    if (applicationOnCreate.hasStopped()) {
+      final long stopUptimeMs =
+          applicationOnCreate.getStartUptimeMs() + applicationOnCreate.getDurationMs();
+      stopHeadlessAppStartAt(stopUptimeMs);
+      return;
+    }
+
+    // Priority 2: API 35+ ApplicationStartInfo (cached from registerLifecycleCallbacks)
+    if (cachedStartInfo != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+      try {
+        final @NotNull Map<Integer, Long> timestamps = cachedStartInfo.getStartupTimestamps();
+        final @Nullable Long onCreateStartNanos =
+            timestamps.get(ApplicationStartInfo.START_TIMESTAMP_APPLICATION_ONCREATE);
+        if (onCreateStartNanos != null) {
+          // The framework captures this timestamp with SystemClock.uptimeNanos() right *before*
+          // invoking Application.onCreate (see ActivityThread.handleBindApplication), so it marks
+          // the onCreate start, not its end. Without plugin instrumentation there is no onCreate
+          // end signal, so this is the best available lower bound for the app start end time.
+          // Same clock base as TimeSpan, so it can be used directly without re-anchoring.
+          final long onCreateStartUptimeMs = TimeUnit.NANOSECONDS.toMillis(onCreateStartNanos);
+          stopHeadlessAppStartAt(onCreateStartUptimeMs);
+          return;
+        }
+      } catch (Throwable ignored) {
+        // Best effort: never let optional startup timestamp enrichment break app startup.
+      }
+    }
+
+    // Priority 3: Process init end time (CLASS_LOADED_UPTIME_MS)
+    stopHeadlessAppStartAt(CLASS_LOADED_UPTIME_MS);
+  }
+
+  private void stopHeadlessAppStartAt(final long stopUptimeMs) {
+    if (appStartSpan.hasStarted()) {
+      if (appStartSpan.hasNotStopped()) {
+        appStartSpan.setStoppedAt(stopUptimeMs);
+      }
+    } else if (sdkInitTimeSpan.hasStarted() && sdkInitTimeSpan.hasNotStopped()) {
+      sdkInitTimeSpan.setStoppedAt(stopUptimeMs);
     }
   }
 
@@ -413,7 +564,9 @@ public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle saved
     if (activeActivitiesCounter.incrementAndGet() == 1 && !firstDrawDone.get()) {
       final long nowUptimeMs = SystemClock.uptimeMillis();
 
-      // If the app (process) was launched more than 1 minute ago, consider it a warm start
+      // If the app (process) was launched more than 1 minute ago, consider it a warm start.
+      // NOTE: meaningless in standalone app start mode, where a headless start is already its own
+      // standalone transaction and therefore cannot be re-classified as warm.
       final long durationSinceAppStartMillis = nowUptimeMs - appStartSpan.getStartUptimeMs();
       if (!appLaunchedInForeground.getValue()
           || durationSinceAppStartMillis > TimeUnit.MINUTES.toMillis(1)) {
@@ -472,7 +625,11 @@ public void onActivityStopped(@NonNull Activity activity) {
   public void onActivityDestroyed(@NonNull Activity activity) {
     CurrentActivityHolder.getInstance().clearActivity(activity);
 
-    final int remainingActivities = activeActivitiesCounter.decrementAndGet();
+    int remainingActivities = activeActivitiesCounter.decrementAndGet();
+    if (remainingActivities < 0) {
+      activeActivitiesCounter.set(0);
+      remainingActivities = 0;
+    }
     // if the app is moving into background
     // as the next onActivityCreated will treat it as a new warm app start
     if (remainingActivities == 0 && !activity.isChangingConfigurations()) {
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
index 9e94d7b9905..f2ffb4b4b96 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
@@ -7,6 +7,7 @@ import android.app.Application
 import android.content.Context
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
 import android.os.Looper
 import android.view.View
 import android.view.ViewTreeObserver
@@ -22,17 +23,21 @@ import io.sentry.Sentry
 import io.sentry.SentryDate
 import io.sentry.SentryDateProvider
 import io.sentry.SentryNanotimeDate
+import io.sentry.SentryTraceHeader
 import io.sentry.SentryTracer
 import io.sentry.Span
+import io.sentry.SpanId
 import io.sentry.SpanStatus
 import io.sentry.SpanStatus.OK
 import io.sentry.TraceContext
+import io.sentry.TracesSamplingDecision
 import io.sentry.TransactionContext
 import io.sentry.TransactionFinishedCallback
 import io.sentry.TransactionOptions
 import io.sentry.android.core.performance.AppStartMetrics
 import io.sentry.android.core.performance.AppStartMetrics.AppStartType
 import io.sentry.protocol.MeasurementValue
+import io.sentry.protocol.SentryId
 import io.sentry.protocol.TransactionNameSource
 import io.sentry.test.DeferredExecutorService
 import io.sentry.test.getProperty
@@ -52,6 +57,7 @@ import kotlin.test.assertSame
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.ArgumentCaptor
+import org.mockito.Mockito.mockStatic
 import org.mockito.kotlin.any
 import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.argumentCaptor
@@ -64,6 +70,7 @@ import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
 import org.robolectric.shadow.api.Shadow
 import org.robolectric.shadows.ShadowActivityManager
 
@@ -83,6 +90,9 @@ class ActivityLifecycleIntegrationTest {
     // start it
     var transaction: SentryTracer = mock()
     val buildInfo = mock<BuildInfoProvider>()
+    val createdTransactions = mutableListOf<SentryTracer>()
+    val capturedContexts = mutableListOf<TransactionContext>()
+    val capturedOptions = mutableListOf<TransactionOptions>()
 
     fun getSut(
       apiVersion: Int = Build.VERSION_CODES.Q,
@@ -102,8 +112,13 @@ class ActivityLifecycleIntegrationTest {
       val contextCaptor = argumentCaptor<TransactionContext>()
       whenever(scopes.startTransaction(contextCaptor.capture(), optionCaptor.capture()))
         .thenAnswer {
-          val t = SentryTracer(contextCaptor.lastValue, scopes, optionCaptor.lastValue)
+          val context = contextCaptor.lastValue
+          val options = optionCaptor.lastValue
+          val t = SentryTracer(context, scopes, options)
           transaction = t
+          createdTransactions.add(t)
+          capturedContexts.add(context)
+          capturedOptions.add(options)
           return@thenAnswer t
         }
       whenever(buildInfo.sdkInfoVersion).thenReturn(apiVersion)
@@ -225,6 +240,192 @@ class ActivityLifecycleIntegrationTest {
       )
   }
 
+  @Test
+  fun `Standalone app start transaction op is app start`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    verify(fixture.scopes, times(2)).startTransaction(any(), any<TransactionOptions>())
+
+    val contexts = fixture.capturedContexts
+    val appStartContext =
+      contexts.single { it.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP }
+    assertEquals("App Start", appStartContext.name)
+    assertEquals(TransactionNameSource.COMPONENT, appStartContext.transactionNameSource)
+    val appStartTransaction =
+      fixture.createdTransactions.single {
+        it.spanContext.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+      }
+    assertEquals("Activity", appStartTransaction.getData("app.vitals.start.screen"))
+    assertTrue(contexts.any { it.operation == ActivityLifecycleIntegration.UI_LOAD_OP })
+    assertFalse(
+      contexts.any {
+        it.operation == ActivityLifecycleIntegration.APP_START_COLD ||
+          it.operation == ActivityLifecycleIntegration.APP_START_WARM
+      }
+    )
+  }
+
+  @Test
+  fun `HeadlessAppStartListener is registered when standalone flag is on and performance enabled`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    prepareHeadlessAppStart(appStartType = AppStartType.UNKNOWN)
+
+    driveHeadlessAppStart()
+
+    assertEquals(1, fixture.capturedContexts.size)
+    assertEquals(
+      ActivityLifecycleIntegration.STANDALONE_APP_START_OP,
+      fixture.capturedContexts.single().operation,
+    )
+    assertEquals("App Start", fixture.capturedContexts.single().name)
+  }
+
+  @Test
+  fun `HeadlessAppStartListener is not registered when standalone flag is off`() {
+    val sut = fixture.getSut { it.tracesSampleRate = 1.0 }
+    sut.register(fixture.scopes, fixture.options)
+    prepareHeadlessAppStart()
+
+    driveHeadlessAppStart()
+
+    verify(fixture.scopes, never()).startTransaction(any(), any<TransactionOptions>())
+  }
+
+  @Test
+  fun `HeadlessAppStartListener is not registered when performance is disabled`() {
+    val sut = fixture.getSut { it.isEnableStandaloneAppStartTracing = true }
+    sut.register(fixture.scopes, fixture.options)
+    prepareHeadlessAppStart()
+
+    driveHeadlessAppStart()
+
+    verify(fixture.scopes, never()).startTransaction(any(), any<TransactionOptions>())
+  }
+
+  @Test
+  fun `close clears HeadlessAppStartListener`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    sut.close()
+    prepareHeadlessAppStart()
+
+    driveHeadlessAppStart()
+
+    verify(fixture.scopes, never()).startTransaction(any(), any<TransactionOptions>())
+  }
+
+  @Test
+  fun `onHeadlessAppStart creates standalone App Start transaction and stashes trace id`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    prepareHeadlessAppStart(appStartType = AppStartType.COLD)
+
+    driveHeadlessAppStart()
+
+    assertEquals(1, fixture.capturedContexts.size)
+    val context = fixture.capturedContexts.single()
+    val options = fixture.capturedOptions.single()
+    val transaction = fixture.createdTransactions.single()
+    assertEquals(ActivityLifecycleIntegration.STANDALONE_APP_START_OP, context.operation)
+    assertEquals("App Start", context.name)
+    assertEquals(TransactionNameSource.COMPONENT, context.transactionNameSource)
+    assertEquals("auto.app.start", options.origin)
+    assertFalse(options.isBindToScope)
+    assertEquals(DateUtils.millisToNanos(100), options.startTimestamp!!.nanoTimestamp())
+    assertEquals(
+      transaction.spanContext.traceId,
+      AppStartMetrics.getInstance().getAppStartTraceId(),
+    )
+    assertTrue(transaction.isFinished)
+    assertEquals(SpanStatus.OK, transaction.status)
+  }
+
+  @Test
+  @Config(sdk = [Build.VERSION_CODES.M])
+  fun `onHeadlessAppStart creates standalone App Start transaction on API 23`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    prepareHeadlessSdkInitAppStart()
+
+    driveHeadlessAppStart()
+
+    assertEquals(1, fixture.capturedContexts.size)
+    val context = fixture.capturedContexts.single()
+    val options = fixture.capturedOptions.single()
+    val transaction = fixture.createdTransactions.single()
+    assertEquals(ActivityLifecycleIntegration.STANDALONE_APP_START_OP, context.operation)
+    assertEquals("App Start", context.name)
+    assertEquals(DateUtils.millisToNanos(100), options.startTimestamp!!.nanoTimestamp())
+    assertEquals(
+      transaction.spanContext.traceId,
+      AppStartMetrics.getInstance().getAppStartTraceId(),
+    )
+    assertTrue(transaction.isFinished)
+    assertEquals(SpanStatus.OK, transaction.status)
+  }
+
+  @Test
+  fun `onHeadlessAppStart creates standalone App Start transaction when appStartType is WARM`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    prepareHeadlessAppStart(appStartType = AppStartType.WARM)
+
+    driveHeadlessAppStart()
+
+    assertEquals(1, fixture.capturedContexts.size)
+    val context = fixture.capturedContexts.single()
+    assertEquals(ActivityLifecycleIntegration.STANDALONE_APP_START_OP, context.operation)
+    assertEquals("App Start", context.name)
+    assertEquals(TransactionNameSource.COMPONENT, context.transactionNameSource)
+  }
+
+  @Test
+  fun `onHeadlessAppStart does nothing when appStartTimeSpan is incomplete`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    AppStartMetrics.getInstance().appStartTimeSpan.reset()
+    AppStartMetrics.getInstance().sdkInitTimeSpan.reset()
+
+    driveHeadlessAppStart()
+
+    verify(fixture.scopes, never()).startTransaction(any(), any<TransactionOptions>())
+  }
+
   @Test
   fun `Activity transaction uses custom deadline timeout when autoTransactionDeadlineTimeoutMillis is set to positive value`() {
     val sut = fixture.getSut()
@@ -528,6 +729,28 @@ class ActivityLifecycleIntegrationTest {
     assertTrue(span.isFinished)
   }
 
+  @Test
+  fun `When Activity is destroyed, sets standalone appStartTransaction status to cancelled and finish it`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+    sut.onActivityDestroyed(activity)
+
+    val appStartTransaction =
+      fixture.createdTransactions[
+          transactionIndexForOperation(ActivityLifecycleIntegration.STANDALONE_APP_START_OP)]
+    assertEquals(SpanStatus.CANCELLED, appStartTransaction.status)
+    assertTrue(appStartTransaction.isFinished)
+  }
+
   @Test
   fun `When Activity is destroyed, sets appStartSpan to null`() {
     val sut = fixture.getSut()
@@ -882,6 +1105,282 @@ class ActivityLifecycleIntegrationTest {
     assertNull(appStartSpan)
   }
 
+  @Test
+  fun `launcher activity emits ui load and standalone App Start sharing trace id`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    val firstFrameDate = SentryNanotimeDate(Date(1499), 0)
+    fixture.options.dateProvider = SentryDateProvider { firstFrameDate }
+    setAppStartTime(SentryNanotimeDate(Date(1), 0))
+
+    val activity = mock<Activity>()
+    sut.onActivityPreCreated(activity, fixture.bundle)
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    assertEquals(2, fixture.capturedContexts.size)
+    val uiLoadIndex = transactionIndexForOperation(ActivityLifecycleIntegration.UI_LOAD_OP)
+    val appStartIndex =
+      transactionIndexForOperation(ActivityLifecycleIntegration.STANDALONE_APP_START_OP)
+    val uiLoadTransaction = fixture.createdTransactions[uiLoadIndex]
+    val appStartTransaction = fixture.createdTransactions[appStartIndex]
+
+    assertEquals(uiLoadTransaction.spanContext.traceId, appStartTransaction.spanContext.traceId)
+    assertEquals("auto.app.start", fixture.capturedOptions[appStartIndex].origin)
+    assertEquals("auto.ui.activity", fixture.capturedOptions[uiLoadIndex].origin)
+    assertFalse(fixture.capturedOptions[appStartIndex].isBindToScope)
+    assertFalse(
+      uiLoadTransaction.children.any {
+        it.operation == ActivityLifecycleIntegration.APP_START_COLD ||
+          it.operation == ActivityLifecycleIntegration.APP_START_WARM
+      }
+    )
+
+    sut.onActivityPostCreated(activity, fixture.bundle)
+    sut.onActivityPreStarted(activity)
+    sut.onActivityStarted(activity)
+    sut.onActivityPostStarted(activity)
+
+    assertTrue(appStartTransaction.children.any { it.operation == "activity.load" })
+
+    sut.onActivityResumed(activity)
+    runFirstDraw(fixture.createView())
+
+    val ttidSpan =
+      uiLoadTransaction.children.single { it.operation == ActivityLifecycleIntegration.TTID_OP }
+    assertTrue(ttidSpan.isFinished)
+    assertTrue(appStartTransaction.isFinished)
+    assertEquals(ttidSpan.finishDate, appStartTransaction.finishDate)
+    assertEquals(
+      ttidSpan.measurements[MeasurementValue.KEY_TIME_TO_INITIAL_DISPLAY]!!.value,
+      AppStartMetrics.getInstance().appStartTimeSpan.durationMs,
+    )
+  }
+
+  @Test
+  fun `launcher activity attaches lifecycle spans before finishing stopped standalone App Start`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    val appStartEndDate = SentryNanotimeDate(Date(499), 0)
+    setAppStartTime(SentryNanotimeDate(Date(1), 0), appStartEndDate)
+
+    val activity = mock<Activity>()
+    sut.onActivityPreCreated(activity, fixture.bundle)
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val appStartIndex =
+      transactionIndexForOperation(ActivityLifecycleIntegration.STANDALONE_APP_START_OP)
+    val appStartTransaction = fixture.createdTransactions[appStartIndex]
+    assertFalse(appStartTransaction.isFinished)
+
+    sut.onActivityPostCreated(activity, fixture.bundle)
+    sut.onActivityPreStarted(activity)
+    sut.onActivityStarted(activity)
+    sut.onActivityPostStarted(activity)
+
+    val activityLoadSpans = appStartTransaction.children.filter { it.operation == "activity.load" }
+    assertEquals(2, activityLoadSpans.size)
+    assertTrue(activityLoadSpans.all { it.isFinished })
+    assertTrue(appStartTransaction.isFinished)
+    assertEquals(appStartEndDate.nanoTimestamp(), appStartTransaction.finishDate!!.nanoTimestamp())
+  }
+
+  @Test
+  fun `activity following a headless start reuses trace id and does not emit second standalone`() {
+    val storedTraceId = SentryId()
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    AppStartMetrics.getInstance().setAppStartTraceId(storedTraceId)
+    // headless start always stores the trace header alongside the trace id; the ui.load txn
+    // continues that trace via continueTrace, sharing the trace id.
+    AppStartMetrics.getInstance().appStartSentryTraceHeader =
+      SentryTraceHeader(storedTraceId, SpanId(), true).value
+    sut.register(fixture.scopes, fixture.options)
+    setAppStartTime()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    assertEquals(1, fixture.capturedContexts.size)
+    val context = fixture.capturedContexts.single()
+    assertEquals(ActivityLifecycleIntegration.UI_LOAD_OP, context.operation)
+    assertEquals(storedTraceId, context.traceId)
+    assertNull(AppStartMetrics.getInstance().getAppStartTraceId())
+  }
+
+  @Test
+  fun `activity within a minute of the headless start continues the same trace`() {
+    val storedTraceId = SentryId()
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    AppStartMetrics.getInstance().setAppStartTraceId(storedTraceId)
+    AppStartMetrics.getInstance().appStartSentryTraceHeader =
+      SentryTraceHeader(storedTraceId, SpanId(), true).value
+    // headless start ended right before the activity opens
+    AppStartMetrics.getInstance().appStartEndTime = SentryNanotimeDate(Date(0), 0)
+    sut.register(fixture.scopes, fixture.options)
+    setAppStartTime(date = SentryNanotimeDate(Date(1), 0))
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val context = fixture.capturedContexts.single()
+    assertEquals(ActivityLifecycleIntegration.UI_LOAD_OP, context.operation)
+    assertEquals(storedTraceId, context.traceId)
+  }
+
+  @Test
+  fun `activity more than a minute after the headless start starts a fresh trace`() {
+    val storedTraceId = SentryId()
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    AppStartMetrics.getInstance().setAppStartTraceId(storedTraceId)
+    AppStartMetrics.getInstance().appStartSentryTraceHeader =
+      SentryTraceHeader(storedTraceId, SpanId(), true).value
+    // headless start ended at epoch, but the activity opens more than a minute later
+    AppStartMetrics.getInstance().appStartEndTime = SentryNanotimeDate(Date(0), 0)
+    sut.register(fixture.scopes, fixture.options)
+    setAppStartTime(date = SentryNanotimeDate(Date(TimeUnit.MINUTES.toMillis(2)), 0))
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val context = fixture.capturedContexts.single()
+    assertEquals(ActivityLifecycleIntegration.UI_LOAD_OP, context.operation)
+    // too far apart: the ui.load gets its own fresh trace, not the stored one
+    assertNotEquals(storedTraceId, context.traceId)
+    // stored continuation state is still consumed so nothing reuses it
+    assertNull(AppStartMetrics.getInstance().getAppStartTraceId())
+  }
+
+  @Test
+  fun `onHeadlessAppStart stores sentry-trace and baggage headers for continuation`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    prepareHeadlessAppStart(appStartType = AppStartType.COLD)
+
+    driveHeadlessAppStart()
+
+    val transaction = fixture.createdTransactions.single()
+    val metrics = AppStartMetrics.getInstance()
+    val sentryTraceHeader = metrics.appStartSentryTraceHeader
+    val baggageHeader = metrics.appStartBaggageHeader
+    assertNotNull(sentryTraceHeader)
+    assertNotNull(baggageHeader)
+    // sentry-trace carries the standalone app.start trace id so a later ui.load txn can continue it
+    assertTrue(sentryTraceHeader.startsWith(transaction.spanContext.traceId.toString()))
+  }
+
+  @Test
+  fun `launcher activity shares standalone App Start trace and sampleRand as a sibling`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    setAppStartTime()
+    // the app-start sampling decision carries the sampleRand the whole trace should share
+    AppStartMetrics.getInstance()
+      .setAppStartSamplingDecision(TracesSamplingDecision(true, 1.0, 0.42))
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    assertEquals(2, fixture.capturedContexts.size)
+    val appStartIndex =
+      transactionIndexForOperation(ActivityLifecycleIntegration.STANDALONE_APP_START_OP)
+    val uiLoadIndex = transactionIndexForOperation(ActivityLifecycleIntegration.UI_LOAD_OP)
+    // app.start is created first so it roots the trace; ui.load shares it
+    assertTrue(appStartIndex < uiLoadIndex)
+
+    val appStartContext = fixture.capturedContexts[appStartIndex]
+    val uiLoadContext = fixture.capturedContexts[uiLoadIndex]
+    assertEquals(appStartContext.traceId, uiLoadContext.traceId)
+    // both share the same sampleRand
+    assertEquals(0.42, appStartContext.baggage?.sampleRand)
+    assertEquals(0.42, uiLoadContext.baggage?.sampleRand)
+    // siblings, not parent/child: ui.load has no parent span id
+    assertNull(uiLoadContext.parentSpanId)
+  }
+
+  @Test
+  fun `activity following a headless start shares stored trace and sampleRand as a sibling and clears headers`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    // 1) a headless start emits the standalone app.start and stores its trace headers
+    prepareHeadlessAppStart(appStartType = AppStartType.COLD)
+    driveHeadlessAppStart()
+    val appStartTransaction = fixture.createdTransactions.single()
+
+    // 2) an activity opens and shares the stored trace instead of emitting a second standalone
+    setAppStartTime()
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val uiLoadContext =
+      fixture.capturedContexts.last { it.operation == ActivityLifecycleIntegration.UI_LOAD_OP }
+    assertFalse(
+      fixture.capturedContexts.drop(1).any {
+        it.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+      }
+    )
+    assertEquals(appStartTransaction.spanContext.traceId, uiLoadContext.traceId)
+    // siblings, not parent/child: ui.load has no parent span id
+    assertNull(uiLoadContext.parentSpanId)
+
+    // stored continuation state is consumed
+    assertNull(AppStartMetrics.getInstance().getAppStartTraceId())
+    assertNull(AppStartMetrics.getInstance().appStartSentryTraceHeader)
+    assertNull(AppStartMetrics.getInstance().appStartBaggageHeader)
+  }
+
+  @Test
+  fun `standalone flag off launcher activity emits single ui load with nested app start cold child`() {
+    val sut = fixture.getSut { it.tracesSampleRate = 1.0 }
+    sut.register(fixture.scopes, fixture.options)
+    setAppStartTime()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    assertEquals(1, fixture.capturedContexts.size)
+    assertEquals(
+      ActivityLifecycleIntegration.UI_LOAD_OP,
+      fixture.capturedContexts.single().operation,
+    )
+    assertTrue(
+      fixture.createdTransactions.single().children.any {
+        it.operation == ActivityLifecycleIntegration.APP_START_COLD
+      }
+    )
+  }
+
   @Test
   fun `When SentryPerformanceProvider is disabled, app start time span is still created`() {
     val sut = fixture.getSut(importance = RunningAppProcessInfo.IMPORTANCE_FOREGROUND)
@@ -1737,6 +2236,59 @@ class ActivityLifecycleIntegrationTest {
     shadowOf(Looper.getMainLooper()).idle()
   }
 
+  private fun driveHeadlessAppStart() {
+    // A headless start (broadcast/service) runs in a non-foreground-importance process. The
+    // foreground guard in AppStartMetrics suppresses the headless path for foreground processes
+    // (deferred init inside an Activity), so headless scenarios must simulate background
+    // importance.
+    mockStatic(ContextUtils::class.java).use { contextUtils ->
+      contextUtils.`when`<Boolean> { ContextUtils.isForegroundImportance() }.thenReturn(false)
+      AppStartMetrics.getInstance().registerLifecycleCallbacks(mock<Application>())
+      waitForMainLooperIdle()
+    }
+  }
+
+  private fun waitForMainLooperIdle() {
+    Handler(Looper.getMainLooper()).post {}
+    shadowOf(Looper.getMainLooper()).idle()
+  }
+
+  private fun prepareHeadlessAppStart(
+    appStartType: AppStartType = AppStartType.COLD,
+    startUptimeMs: Long = 100,
+    endUptimeMs: Long = 200,
+  ) {
+    AppStartMetrics.getInstance().apply {
+      this.appStartType = appStartType
+      setClassLoadedUptimeMs(endUptimeMs)
+      appStartTimeSpan.apply {
+        setStartedAt(startUptimeMs)
+        setStartUnixTimeMs(startUptimeMs)
+      }
+      sdkInitTimeSpan.apply {
+        setStartedAt(startUptimeMs)
+        setStartUnixTimeMs(startUptimeMs)
+      }
+    }
+  }
+
+  private fun prepareHeadlessSdkInitAppStart(startUptimeMs: Long = 100, endUptimeMs: Long = 200) {
+    AppStartMetrics.getInstance().apply {
+      appStartTimeSpan.reset()
+      sdkInitTimeSpan.apply {
+        setStartedAt(startUptimeMs)
+        setStartUnixTimeMs(startUptimeMs)
+      }
+      setClassLoadedUptimeMs(endUptimeMs)
+    }
+  }
+
+  private fun transactionIndexForOperation(operation: String): Int {
+    val index = fixture.capturedContexts.indexOfFirst { it.operation == operation }
+    assertTrue(index >= 0)
+    return index
+  }
+
   private fun setAppStartTime(
     date: SentryDate = SentryNanotimeDate(Date(1), 0),
     stopDate: SentryDate? = null,
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index d8ac959601a..3b12e6489a7 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -1492,6 +1492,36 @@ class ManifestMetadataReaderTest {
     assertTrue(fixture.options.isEnablePerformanceV2)
   }
 
+  @Test
+  fun `applyMetadata reads standalone app start tracing flag to options`() {
+    val bundle = bundleOf(ManifestMetadataReader.ENABLE_STANDALONE_APP_START_TRACING to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    assertTrue(fixture.options.isEnableStandaloneAppStartTracing)
+  }
+
+  @Test
+  fun `applyMetadata reads standalone app start tracing false to options`() {
+    fixture.options.isEnableStandaloneAppStartTracing = true
+    val bundle = bundleOf(ManifestMetadataReader.ENABLE_STANDALONE_APP_START_TRACING to false)
+    val context = fixture.getContext(metaData = bundle)
+
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    assertFalse(fixture.options.isEnableStandaloneAppStartTracing)
+  }
+
+  @Test
+  fun `applyMetadata reads standalone app start tracing flag to options and keeps default if not found`() {
+    val context = fixture.getContext()
+
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    assertFalse(fixture.options.isEnableStandaloneAppStartTracing)
+  }
+
   @Test
   fun `applyMetadata reads startupProfiling flag to options`() {
     // Arrange
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/PerformanceAndroidEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/PerformanceAndroidEventProcessorTest.kt
index e2fed5bb003..173b4e3d999 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/PerformanceAndroidEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/PerformanceAndroidEventProcessorTest.kt
@@ -13,7 +13,9 @@ import io.sentry.SpanStatus
 import io.sentry.TracesSamplingDecision
 import io.sentry.TransactionContext
 import io.sentry.android.core.ActivityLifecycleIntegration.APP_START_COLD
+import io.sentry.android.core.ActivityLifecycleIntegration.APP_START_SCREEN_DATA
 import io.sentry.android.core.ActivityLifecycleIntegration.APP_START_WARM
+import io.sentry.android.core.ActivityLifecycleIntegration.STANDALONE_APP_START_OP
 import io.sentry.android.core.ActivityLifecycleIntegration.UI_LOAD_OP
 import io.sentry.android.core.performance.ActivityLifecycleTimeSpan
 import io.sentry.android.core.performance.AppStartMetrics
@@ -87,7 +89,7 @@ class PerformanceAndroidEventProcessorTest {
   fun `add cold start measurement`() {
     val sut = fixture.getSut()
 
-    var tr = getTransaction(AppStartType.COLD)
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
     setAppStart(fixture.options)
 
     tr = sut.process(tr, Hint())
@@ -95,11 +97,106 @@ class PerformanceAndroidEventProcessorTest {
     assertTrue(tr.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
   }
 
+  @Test
+  fun `add cold start measurement for standalone app start transaction launched from background`() {
+    val sut = fixture.getSut()
+
+    var tr = createStandaloneAppStartTransaction()
+    setStandaloneColdAppStartMetrics()
+
+    tr = sut.process(tr, Hint())
+
+    assertTrue(tr.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
+  }
+
+  @Test
+  fun `standalone app start with instrumented application onCreate attaches process and application spans`() {
+    val sut = fixture.getSut(enablePerformanceV2 = true)
+    setStandaloneColdAppStartMetrics(withApplicationOnCreate = true)
+
+    var tr = createStandaloneAppStartTransaction()
+    val rootSpanId = tr.contexts.trace!!.spanId
+
+    tr = sut.process(tr, Hint())
+
+    assertTrue(tr.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
+    assertEquals(listOf("process.load", "application.load"), tr.spans.map { it.op })
+    assertTrue(tr.spans.all { it.parentSpanId == rootSpanId })
+  }
+
+  @Test
+  fun `standalone app start without instrumented application onCreate attaches only process span`() {
+    val sut = fixture.getSut(enablePerformanceV2 = true)
+    setStandaloneColdAppStartMetrics(withApplicationOnCreate = false)
+
+    var tr = createStandaloneAppStartTransaction()
+    val rootSpanId = tr.contexts.trace!!.spanId
+
+    tr = sut.process(tr, Hint())
+
+    assertTrue(tr.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
+    assertEquals(listOf("process.load"), tr.spans.map { it.op })
+    assertEquals(rootSpanId, tr.spans.single().parentSpanId)
+  }
+
+  @Test
+  fun `standalone app start uses the transaction root span id as parent`() {
+    val sut = fixture.getSut(enablePerformanceV2 = true)
+    setStandaloneColdAppStartMetrics()
+
+    var tr = createStandaloneAppStartTransaction()
+    val rootSpanId = tr.contexts.trace!!.spanId
+
+    tr = sut.process(tr, Hint())
+
+    val processLoadSpan = tr.spans.first { it.op == "process.load" }
+    assertEquals(rootSpanId, processLoadSpan.parentSpanId)
+  }
+
+  @Test
+  fun `standalone app start spans do not carry TTID or TTFD contributing flags`() {
+    val sut = fixture.getSut(enablePerformanceV2 = true)
+    setStandaloneColdAppStartMetrics(withApplicationOnCreate = true)
+
+    var tr = createStandaloneAppStartTransaction()
+
+    tr = sut.process(tr, Hint())
+
+    assertTrue(tr.spans.isNotEmpty())
+    for (span in tr.spans) {
+      assertNull(span.data?.get(SpanDataConvention.CONTRIBUTES_TTID))
+      assertNull(span.data?.get(SpanDataConvention.CONTRIBUTES_TTFD))
+    }
+  }
+
+  @Test
+  fun `foreground standalone app start measurement uses foreground fallback time span`() {
+    val sut = fixture.getSut(enablePerformanceV2 = false)
+    AppStartMetrics.getInstance().apply {
+      appStartType = AppStartType.COLD
+      isAppLaunchedInForeground = true
+      appStartTimeSpan.apply {
+        setStartedAt(1)
+        setStoppedAt(101)
+      }
+      sdkInitTimeSpan.apply {
+        setStartedAt(10)
+        setStoppedAt(30)
+      }
+    }
+
+    var tr = createStandaloneAppStartTransaction(appStartScreen = "MainActivity")
+
+    tr = sut.process(tr, Hint())
+
+    assertEquals(20f, tr.measurements[MeasurementValue.KEY_APP_START_COLD]?.value)
+  }
+
   @Test
   fun `add cold start measurement for performance-v2`() {
     val sut = fixture.getSut(enablePerformanceV2 = true)
 
-    var tr = getTransaction(AppStartType.COLD)
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
     setAppStart(fixture.options)
 
     tr = sut.process(tr, Hint())
@@ -111,7 +208,7 @@ class PerformanceAndroidEventProcessorTest {
   fun `add warm start measurement`() {
     val sut = fixture.getSut()
 
-    var tr = getTransaction(AppStartType.WARM)
+    var tr = createUiLoadTransactionWithAppStartChildSpan(coldStart = false)
     setAppStart(fixture.options, false)
 
     tr = sut.process(tr, Hint())
@@ -123,7 +220,7 @@ class PerformanceAndroidEventProcessorTest {
   fun `set app cold start unit measurement`() {
     val sut = fixture.getSut()
 
-    var tr = getTransaction(AppStartType.COLD)
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
     setAppStart(fixture.options)
 
     tr = sut.process(tr, Hint())
@@ -136,23 +233,40 @@ class PerformanceAndroidEventProcessorTest {
   fun `do not add app start metric twice`() {
     val sut = fixture.getSut()
 
-    var tr1 = getTransaction(AppStartType.COLD)
+    var tr1 = createUiLoadTransactionWithAppStartChildSpan()
     setAppStart(fixture.options, false)
 
     tr1 = sut.process(tr1, Hint())
 
-    var tr2 = getTransaction(AppStartType.UNKNOWN)
+    var tr2 = createUiLoadTransaction()
     tr2 = sut.process(tr2, Hint())
 
     assertTrue(tr1.measurements.containsKey(MeasurementValue.KEY_APP_START_WARM))
     assertTrue(tr2.measurements.isEmpty())
   }
 
+  @Test
+  fun `do not add standalone app start metric twice`() {
+    val sut = fixture.getSut()
+
+    setStandaloneColdAppStartMetrics()
+
+    var tr1 = createStandaloneAppStartTransaction()
+    tr1 = sut.process(tr1, Hint())
+
+    var tr2 = createStandaloneAppStartTransaction()
+    tr2 = sut.process(tr2, Hint())
+
+    assertTrue(tr1.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
+    assertFalse(tr2.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
+    assertFalse(tr2.measurements.containsKey(MeasurementValue.KEY_APP_START_WARM))
+  }
+
   @Test
   fun `do not add app start metric if its not ready`() {
     val sut = fixture.getSut()
 
-    var tr = getTransaction(AppStartType.UNKNOWN)
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
 
     tr = sut.process(tr, Hint())
 
@@ -163,7 +277,7 @@ class PerformanceAndroidEventProcessorTest {
   fun `do not add app start metric if performance is disabled`() {
     val sut = fixture.getSut(tracesSampleRate = null)
 
-    var tr = getTransaction(AppStartType.COLD)
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
 
     tr = sut.process(tr, Hint())
 
@@ -174,7 +288,7 @@ class PerformanceAndroidEventProcessorTest {
   fun `do not add app start metric if no app_start span`() {
     val sut = fixture.getSut(tracesSampleRate = null)
 
-    var tr = getTransaction(AppStartType.UNKNOWN)
+    var tr = createUiLoadTransaction()
 
     tr = sut.process(tr, Hint())
 
@@ -184,7 +298,7 @@ class PerformanceAndroidEventProcessorTest {
   @Test
   fun `do not add slow and frozen frames if not auto transaction`() {
     val sut = fixture.getSut()
-    var tr = getTransaction(AppStartType.UNKNOWN)
+    var tr = createTransaction("custom.op")
 
     tr = sut.process(tr, Hint())
 
@@ -194,7 +308,7 @@ class PerformanceAndroidEventProcessorTest {
   @Test
   fun `do not add slow and frozen frames if tracing is disabled`() {
     val sut = fixture.getSut(null)
-    var tr = getTransaction(AppStartType.UNKNOWN)
+    var tr = createUiLoadTransaction()
 
     tr = sut.process(tr, Hint())
 
@@ -464,10 +578,10 @@ class PerformanceAndroidEventProcessorTest {
     val appStartSpan = createAppStartSpan(tr.contexts.trace!!.traceId)
     tr.spans.add(appStartSpan)
 
-    assertTrue(appStartMetrics.shouldSendStartMeasurements())
+    assertTrue(appStartMetrics.shouldSendStartMeasurements(false))
     // then the app start metrics should be attached
     tr = sut.process(tr, Hint())
-    assertFalse(appStartMetrics.shouldSendStartMeasurements())
+    assertFalse(appStartMetrics.shouldSendStartMeasurements(false))
 
     assertTrue(tr.spans.any { "application.load" == it.op })
 
@@ -867,13 +981,44 @@ class PerformanceAndroidEventProcessorTest {
     }
   }
 
-  private fun getTransaction(type: AppStartType): SentryTransaction {
-    val op =
-      when (type) {
-        AppStartType.COLD -> "app.start.cold"
-        AppStartType.WARM -> "app.start.warm"
-        AppStartType.UNKNOWN -> "ui.load"
+  private fun setStandaloneColdAppStartMetrics(withApplicationOnCreate: Boolean = false) {
+    AppStartMetrics.getInstance().apply {
+      appStartType = AppStartType.COLD
+      isAppLaunchedInForeground = false
+      classLoadedUptimeMs = 50
+      appStartTimeSpan.apply {
+        setStartedAt(1)
+        setStoppedAt(100)
+      }
+      if (withApplicationOnCreate) {
+        applicationOnCreateTimeSpan.apply {
+          setStartedAt(10)
+          description = "com.example.App.onCreate"
+          setStoppedAt(42)
+        }
       }
+    }
+  }
+
+  private fun createUiLoadTransactionWithAppStartChildSpan(
+    coldStart: Boolean = true
+  ): SentryTransaction =
+    createUiLoadTransaction().also { txn ->
+      txn.spans.add(createAppStartSpan(txn.contexts.trace!!.traceId, coldStart))
+    }
+
+  private fun createUiLoadTransaction(): SentryTransaction = createTransaction(UI_LOAD_OP)
+
+  private fun createStandaloneAppStartTransaction(
+    appStartScreen: String? = null
+  ): SentryTransaction =
+    createTransaction(STANDALONE_APP_START_OP).also { txn ->
+      if (appStartScreen != null) {
+        txn.contexts.trace!!.setData(APP_START_SCREEN_DATA, appStartScreen)
+      }
+    }
+
+  private fun createTransaction(op: String): SentryTransaction {
     val txn = SentryTransaction(fixture.tracer)
     txn.contexts.setTrace(SpanContext(op, TracesSamplingDecision(false)))
     return txn
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt
index 819928dcdc4..0eec9502702 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt
@@ -156,6 +156,12 @@ class SentryAndroidOptionsTest {
     assertFalse(sentryOptions.isEnablePerformanceV2)
   }
 
+  @Test
+  fun `standalone app start tracing is disabled by default`() {
+    val sentryOptions = SentryAndroidOptions()
+    assertFalse(sentryOptions.isEnableStandaloneAppStartTracing)
+  }
+
   fun `when options is initialized, enableScopeSync is enabled by default`() {
     assertTrue(SentryAndroidOptions().isEnableScopeSync)
   }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowActivityManager.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowActivityManager.kt
index e7079bd46d0..a959c5dd865 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowActivityManager.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowActivityManager.kt
@@ -1,6 +1,7 @@
 package io.sentry.android.core
 
 import android.app.ActivityManager
+import android.app.ActivityManager.RunningAppProcessInfo
 import android.app.ApplicationStartInfo
 import android.os.Build
 import org.robolectric.annotation.Implementation
@@ -10,13 +11,25 @@ import org.robolectric.annotation.Implements
 class SentryShadowActivityManager {
   companion object {
     private var historicalProcessStartReasons: List<ApplicationStartInfo> = emptyList()
+    private var importance: Int = RunningAppProcessInfo.IMPORTANCE_FOREGROUND
 
     fun setHistoricalProcessStartReasons(startReasons: List<ApplicationStartInfo>) {
       historicalProcessStartReasons = startReasons
     }
 
+    fun setImportance(importance: Int) {
+      this.importance = importance
+    }
+
     fun reset() {
       historicalProcessStartReasons = emptyList()
+      importance = RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+    }
+
+    @Implementation
+    @JvmStatic
+    fun getMyMemoryState(outState: RunningAppProcessInfo) {
+      outState.importance = importance
     }
   }
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowProcess.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowProcess.kt
index c3ff6653673..e36388fb185 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowProcess.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowProcess.kt
@@ -6,15 +6,25 @@ import org.robolectric.annotation.Implements
 @Implements(android.os.Process::class)
 class SentryShadowProcess {
   companion object {
-    private var startupTimeMillis: Long = 0
+    private var startUptimeMillis: Long = 0
+    private var startElapsedRealtime: Long = 0
 
     fun setStartUptimeMillis(value: Long) {
-      startupTimeMillis = value
+      startUptimeMillis = value
     }
 
+    fun setStartElapsedRealtime(value: Long) {
+      startElapsedRealtime = value
+    }
+
+    @Suppress("unused")
+    @Implementation
+    @JvmStatic
+    fun getStartUptimeMillis(): Long = startUptimeMillis
+
     @Suppress("unused")
     @Implementation
     @JvmStatic
-    fun getStartUptimeMillis(): Long = startupTimeMillis
+    fun getStartElapsedRealtime(): Long = startElapsedRealtime
   }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
index c15ea3c37d0..ab0013a8c75 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
@@ -13,11 +13,14 @@ import io.sentry.DateUtils
 import io.sentry.IContinuousProfiler
 import io.sentry.ITransactionProfiler
 import io.sentry.SentryNanotimeDate
+import io.sentry.android.core.ContextUtils
 import io.sentry.android.core.CurrentActivityHolder
 import io.sentry.android.core.SentryAndroidOptions
 import io.sentry.android.core.SentryShadowProcess
+import io.sentry.protocol.SentryId
 import java.util.Date
 import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -27,6 +30,7 @@ import kotlin.test.assertSame
 import kotlin.test.assertTrue
 import org.junit.Before
 import org.junit.runner.RunWith
+import org.mockito.Mockito.mockStatic
 import org.mockito.kotlin.any
 import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
@@ -44,6 +48,7 @@ class AppStartMetricsTest {
   fun setup() {
     AppStartMetrics.getInstance().clear()
     SentryShadowProcess.setStartUptimeMillis(42)
+    AppStartMetrics.getInstance().setClassLoadedUptimeMs(42)
     AppStartMetrics.getInstance().isAppLaunchedInForeground = true
   }
 
@@ -65,6 +70,7 @@ class AppStartMetricsTest {
     metrics.appStartProfiler = mock()
     metrics.appStartContinuousProfiler = mock()
     metrics.appStartSamplingDecision = mock()
+    metrics.setAppStartTraceId(SentryId())
 
     metrics.clear()
 
@@ -78,6 +84,7 @@ class AppStartMetricsTest {
     assertNull(metrics.appStartProfiler)
     assertNull(metrics.appStartContinuousProfiler)
     assertNull(metrics.appStartSamplingDecision)
+    assertNull(metrics.getAppStartTraceId())
   }
 
   @Test
@@ -167,10 +174,10 @@ class AppStartMetricsTest {
     // when the looper runs
     waitForMainLooperIdle()
 
-    // but no activity creation happened
+    // but a headless start happened
     // then the app wasn't launched in foreground and nothing should be sent
     assertFalse(metrics.isAppLaunchedInForeground)
-    assertFalse(metrics.shouldSendStartMeasurements())
+    assertFalse(metrics.shouldSendStartMeasurements(false))
 
     val now = TimeUnit.MINUTES.toMillis(2) + 1234567
     SystemClock.setCurrentTimeMillis(now)
@@ -180,7 +187,7 @@ class AppStartMetricsTest {
 
     // then it should restart the timespan
     assertTrue(metrics.isAppLaunchedInForeground)
-    assertTrue(metrics.shouldSendStartMeasurements())
+    assertTrue(metrics.shouldSendStartMeasurements(false))
     assertTrue(metrics.appStartTimeSpan.hasStarted())
     assertEquals(now, metrics.appStartTimeSpan.startUptimeMs)
     assertFalse(metrics.applicationOnCreateTimeSpan.hasStarted())
@@ -194,7 +201,7 @@ class AppStartMetricsTest {
     metrics.sdkInitTimeSpan.start()
     metrics.registerLifecycleCallbacks(mock<Application>())
 
-    // when the handler callback is executed and no activity was launched
+    // when the handler callback is executed and the start is headless
     waitForMainLooperIdle()
 
     // isAppLaunchedInForeground should be false
@@ -208,11 +215,170 @@ class AppStartMetricsTest {
     assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
   }
 
+  @Test
+  fun `headless app start defaults UNKNOWN appStartType to COLD`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartTimeSpan.setStartedAt(100)
+
+    metrics.registerLifecycleCallbacks(mock<Application>())
+    waitForMainLooperIdle()
+
+    assertEquals(AppStartMetrics.AppStartType.COLD, metrics.appStartType)
+    assertFalse(metrics.isAppLaunchedInForeground)
+  }
+
+  @Test
+  fun `headless app start does not overwrite existing appStartType`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartType = AppStartMetrics.AppStartType.WARM
+    metrics.appStartTimeSpan.setStartedAt(100)
+
+    metrics.registerLifecycleCallbacks(mock<Application>())
+    waitForMainLooperIdle()
+
+    assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
+  }
+
+  @Test
+  fun `headless app start fires HeadlessAppStartListener`() = headlessProcess {
+    val listenerCalls = AtomicInteger()
+
+    AppStartMetrics.getInstance().setHeadlessAppStartListener { listenerCalls.incrementAndGet() }
+    AppStartMetrics.getInstance().registerLifecycleCallbacks(mock<Application>())
+    waitForMainLooperIdle()
+
+    assertEquals(1, listenerCalls.get())
+  }
+
+  @Test
+  fun `foreground process does not fire HeadlessAppStartListener`() {
+    // Deferred/late SDK init inside an already-running Activity: we missed onActivityCreated, but
+    // the process is foreground (Robolectric default importance), so this is a real launch, not a
+    // headless start. The listener must not fire and the headless reclassification must not run.
+    val listenerCalls = AtomicInteger()
+    val metrics = AppStartMetrics.getInstance()
+
+    metrics.setHeadlessAppStartListener { listenerCalls.incrementAndGet() }
+    metrics.registerLifecycleCallbacks(mock<Application>())
+    waitForMainLooperIdle()
+
+    assertEquals(0, listenerCalls.get())
+    assertEquals(AppStartMetrics.AppStartType.UNKNOWN, metrics.appStartType)
+
+    SystemClock.setCurrentTimeMillis(SystemClock.uptimeMillis() + 100)
+    val activity = mock<Activity>()
+    whenever(activity.isChangingConfigurations).thenReturn(false)
+    metrics.onActivityCreated(activity, null)
+
+    assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
+
+    metrics.onActivityDestroyed(activity)
+    SystemClock.setCurrentTimeMillis(SystemClock.uptimeMillis() + 100)
+    metrics.onActivityCreated(mock<Activity>(), null)
+
+    assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
+  }
+
+  @Test
+  fun `activity start prevents HeadlessAppStartListener`() {
+    val listenerCalls = AtomicInteger()
+    val metrics = AppStartMetrics.getInstance()
+
+    metrics.setHeadlessAppStartListener { listenerCalls.incrementAndGet() }
+    metrics.onActivityCreated(mock<Activity>(), null)
+    metrics.registerLifecycleCallbacks(mock<Application>())
+    waitForMainLooperIdle()
+
+    assertEquals(0, listenerCalls.get())
+  }
+
+  @Test
+  fun `resolveHeadlessAppStartEndTime uses applicationOnCreate stop when Gradle plugin instrumented`() =
+    headlessProcess {
+      val metrics = AppStartMetrics.getInstance()
+      metrics.appStartTimeSpan.setStartedAt(100)
+      metrics.setHeadlessAppStartListener {}
+      metrics.applicationOnCreateTimeSpan.apply {
+        setStartedAt(120)
+        setStoppedAt(200)
+      }
+
+      metrics.registerLifecycleCallbacks(mock<Application>())
+      waitForMainLooperIdle()
+
+      assertEquals(100, metrics.appStartTimeSpan.durationMs)
+    }
+
+  @Test
+  fun `resolveHeadlessAppStartEndTime falls back to CLASS_LOADED_UPTIME_MS when no plugin and no ApplicationStartInfo`() =
+    headlessProcess {
+      val metrics = AppStartMetrics.getInstance()
+      metrics.setClassLoadedUptimeMs(200)
+      metrics.appStartTimeSpan.setStartedAt(100)
+      metrics.setHeadlessAppStartListener {}
+
+      metrics.registerLifecycleCallbacks(mock<Application>())
+      waitForMainLooperIdle()
+
+      assertEquals(100, metrics.appStartTimeSpan.durationMs)
+    }
+
+  @Test
+  fun `resolveHeadlessAppStartEndTime does not overwrite stopped appStartTimeSpan`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartTimeSpan.apply {
+      setStartedAt(100)
+      setStoppedAt(150)
+    }
+    metrics.setHeadlessAppStartListener {}
+    metrics.applicationOnCreateTimeSpan.apply {
+      setStartedAt(120)
+      setStoppedAt(200)
+    }
+
+    metrics.registerLifecycleCallbacks(mock<Application>())
+    waitForMainLooperIdle()
+
+    assertEquals(50, metrics.appStartTimeSpan.durationMs)
+  }
+
+  @Test
+  fun `headless app start without listener does not stop sdkInitTimeSpan`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.sdkInitTimeSpan.setStartedAt(100)
+
+    metrics.registerLifecycleCallbacks(mock<Application>())
+    waitForMainLooperIdle()
+
+    assertTrue(metrics.sdkInitTimeSpan.hasNotStopped())
+  }
+
+  @Test
+  fun `getAppStartTimeSpanForHeadless falls back to sdkInitTimeSpan when appStartSpan has not stopped`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartTimeSpan.setStartedAt(100)
+    metrics.sdkInitTimeSpan.apply {
+      setStartedAt(120)
+      setStoppedAt(180)
+    }
+
+    assertSame(metrics.sdkInitTimeSpan, metrics.getAppStartTimeSpanForHeadless())
+  }
+
   private fun waitForMainLooperIdle() {
     Handler(Looper.getMainLooper()).post {}
     Shadows.shadowOf(Looper.getMainLooper()).idle()
   }
 
+  // Simulates a real headless start (broadcast/service), i.e. a non-foreground-importance process.
+  // The Robolectric default importance in this test class is IMPORTANCE_FOREGROUND, so headless
+  // scenarios must opt into a background importance explicitly.
+  private fun <T> headlessProcess(block: () -> T): T =
+    mockStatic(ContextUtils::class.java).use { contextUtils ->
+      contextUtils.`when`<Boolean> { ContextUtils.isForegroundImportance() }.thenReturn(false)
+      block()
+    }
+
   @Test
   fun `if app start span is at most 1 minute, appStartTimeSpanWithFallback returns the app start span`() {
     val appStartTimeSpan = AppStartMetrics.getInstance().appStartTimeSpan
@@ -331,12 +497,12 @@ class AppStartMetricsTest {
   }
 
   @Test
-  fun `registerApplicationForegroundCheck set foreground state to false if no activity is running`() {
+  fun `registerApplicationForegroundCheck set foreground state to false for headless start`() {
     val application = mock<Application>()
     AppStartMetrics.getInstance().isAppLaunchedInForeground = true
     AppStartMetrics.getInstance().registerLifecycleCallbacks(application)
     assertTrue(AppStartMetrics.getInstance().isAppLaunchedInForeground)
-    // Main thread performs the check and sets the flag to false if no activity was created
+    // Main thread performs the check and sets the flag to false if the start is headless
     waitForMainLooperIdle()
     assertFalse(AppStartMetrics.getInstance().isAppLaunchedInForeground)
   }
@@ -369,11 +535,11 @@ class AppStartMetricsTest {
     val appStartMetrics = AppStartMetrics.getInstance()
     appStartMetrics.addActivityLifecycleTimeSpans(mock())
     appStartMetrics.contentProviderOnCreateTimeSpans.add(mock())
-    assertTrue(appStartMetrics.shouldSendStartMeasurements())
+    assertTrue(appStartMetrics.shouldSendStartMeasurements(false))
     appStartMetrics.onAppStartSpansSent()
     assertTrue(appStartMetrics.activityLifecycleTimeSpans.isEmpty())
     assertTrue(appStartMetrics.contentProviderOnCreateTimeSpans.isEmpty())
-    assertFalse(appStartMetrics.shouldSendStartMeasurements())
+    assertFalse(appStartMetrics.shouldSendStartMeasurements(false))
   }
 
   @Test
@@ -387,18 +553,18 @@ class AppStartMetricsTest {
 
     // then the app start type should be cold and measurements should be sent
     assertEquals(AppStartMetrics.AppStartType.COLD, appStartMetrics.appStartType)
-    assertTrue(appStartMetrics.shouldSendStartMeasurements())
+    assertTrue(appStartMetrics.shouldSendStartMeasurements(false))
 
     // when the activity gets destroyed
     appStartMetrics.onAppStartSpansSent()
-    assertFalse(appStartMetrics.shouldSendStartMeasurements())
+    assertFalse(appStartMetrics.shouldSendStartMeasurements(false))
 
     appStartMetrics.onActivityDestroyed(activity0)
 
     // then it should reset sending the measurements for the next warm activity
     appStartMetrics.onActivityCreated(mock<Activity>(), mock<Bundle>())
     assertEquals(AppStartMetrics.AppStartType.WARM, appStartMetrics.appStartType)
-    assertTrue(appStartMetrics.shouldSendStartMeasurements())
+    assertTrue(appStartMetrics.shouldSendStartMeasurements(false))
   }
 
   @Test
@@ -585,7 +751,6 @@ class AppStartMetricsTest {
     waitForMainLooperIdle()
 
     SystemClock.setCurrentTimeMillis(SystemClock.uptimeMillis() + 100)
-    metrics.isAppLaunchedInForeground = true
     metrics.onActivityCreated(mock<Activity>(), null)
 
     assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
@@ -791,7 +956,7 @@ class AppStartMetricsTest {
     whenever(firstActivity.isChangingConfigurations).thenReturn(false)
     metrics.onActivityCreated(firstActivity, null)
     assertEquals(AppStartMetrics.AppStartType.COLD, metrics.appStartType)
-    assertTrue(metrics.shouldSendStartMeasurements())
+    assertTrue(metrics.shouldSendStartMeasurements(false))
     metrics.onAppStartSpansSent()
     waitForMainLooperIdle()
 
@@ -804,7 +969,7 @@ class AppStartMetricsTest {
     metrics.onActivityCreated(secondActivity, null)
     assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
     assertTrue(metrics.isAppLaunchedInForeground)
-    assertTrue(metrics.shouldSendStartMeasurements())
+    assertTrue(metrics.shouldSendStartMeasurements(false))
     metrics.onAppStartSpansSent()
 
     // Third activity - should still be warm
@@ -812,7 +977,7 @@ class AppStartMetricsTest {
     metrics.onActivityCreated(mock<Activity>(), null)
     assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
     assertTrue(metrics.isAppLaunchedInForeground)
-    assertFalse(metrics.shouldSendStartMeasurements())
+    assertFalse(metrics.shouldSendStartMeasurements(false))
   }
 
   @Test
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
index d3738943a2c..30686852156 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
@@ -1,18 +1,25 @@
 package io.sentry.android.core.performance
 
+import android.app.ActivityManager.RunningAppProcessInfo
 import android.app.Application
 import android.app.ApplicationStartInfo
 import android.os.Build
+import android.os.Handler
+import android.os.Looper
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.android.core.SentryShadowActivityManager
 import io.sentry.android.core.SentryShadowProcess
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
 import org.junit.Before
 import org.junit.runner.RunWith
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
+import org.robolectric.Shadows
 import org.robolectric.annotation.Config
 
 @RunWith(AndroidJUnit4::class)
@@ -25,7 +32,9 @@ class AppStartMetricsTestApi35 {
   fun setup() {
     AppStartMetrics.getInstance().clear()
     SentryShadowProcess.setStartUptimeMillis(42)
+    SentryShadowProcess.setStartElapsedRealtime(42)
     SentryShadowActivityManager.reset()
+    AppStartMetrics.getInstance().setClassLoadedUptimeMs(42)
     AppStartMetrics.getInstance().isAppLaunchedInForeground = true
   }
 
@@ -42,6 +51,22 @@ class AppStartMetricsTestApi35 {
     assertEquals(AppStartMetrics.AppStartType.COLD, AppStartMetrics.getInstance().appStartType)
   }
 
+  @Test
+  fun `known ApplicationStartInfo type without listener does not schedule headless check`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    val metrics = AppStartMetrics.getInstance()
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+    waitForMainLooperIdle()
+
+    assertEquals(AppStartMetrics.AppStartType.COLD, metrics.appStartType)
+    assertEquals(-1, metrics.firstIdle)
+  }
+
   @Test
   fun `detects warm start using ApplicationStartInfo on API 35`() {
     val mockStartInfo = mock<ApplicationStartInfo>()
@@ -81,4 +106,109 @@ class AppStartMetricsTestApi35 {
 
     assertEquals(AppStartMetrics.AppStartType.UNKNOWN, metrics.appStartType)
   }
+
+  @Test
+  fun `headless app start keeps COLD appStartType from ApplicationStartInfo`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    whenever(mockStartInfo.startupTimestamps).thenReturn(emptyMap())
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    SentryShadowActivityManager.setImportance(RunningAppProcessInfo.IMPORTANCE_CACHED)
+    val listenerCalls = AtomicInteger()
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartTimeSpan.setStartedAt(100)
+    metrics.setHeadlessAppStartListener { listenerCalls.incrementAndGet() }
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+    waitForMainLooperIdle()
+
+    assertEquals(AppStartMetrics.AppStartType.COLD, metrics.appStartType)
+    assertFalse(metrics.isAppLaunchedInForeground)
+    assertEquals(1, listenerCalls.get())
+  }
+
+  @Test
+  fun `known ApplicationStartInfo type with listener handles headless app start`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_WARM)
+    whenever(mockStartInfo.startupTimestamps).thenReturn(emptyMap())
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    SentryShadowActivityManager.setImportance(RunningAppProcessInfo.IMPORTANCE_CACHED)
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartTimeSpan.setStartedAt(100)
+    metrics.setClassLoadedUptimeMs(200)
+    metrics.setHeadlessAppStartListener {}
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+    waitForMainLooperIdle()
+
+    assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
+    assertFalse(metrics.isAppLaunchedInForeground)
+    assertEquals(100, metrics.appStartTimeSpan.durationMs)
+  }
+
+  @Test
+  fun `resolveHeadlessAppStartEndTime uses ApplicationStartInfo onCreate uptime timestamp`() {
+    val appStartUptimeMs = 100L
+    // START_TIMESTAMP_APPLICATION_ONCREATE is captured with SystemClock.uptimeNanos() (the same
+    // base as TimeSpan) right before Application.onCreate is invoked, so it is used directly as
+    // an uptime value marking the onCreate start, without any clock re-anchoring.
+    val onCreateStartUptimeMs = 350L
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    whenever(mockStartInfo.startupTimestamps)
+      .thenReturn(
+        mapOf(
+          ApplicationStartInfo.START_TIMESTAMP_APPLICATION_ONCREATE to
+            TimeUnit.MILLISECONDS.toNanos(onCreateStartUptimeMs)
+        )
+      )
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    SentryShadowActivityManager.setImportance(RunningAppProcessInfo.IMPORTANCE_CACHED)
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartTimeSpan.setStartedAt(appStartUptimeMs)
+    metrics.setHeadlessAppStartListener {}
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+    waitForMainLooperIdle()
+
+    assertEquals(250, metrics.appStartTimeSpan.durationMs)
+    assertFalse(metrics.applicationOnCreateTimeSpan.hasStarted())
+  }
+
+  @Test
+  fun `listener fires when set after registerLifecycleCallbacks resolves type on API 35`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    whenever(mockStartInfo.startupTimestamps).thenReturn(emptyMap())
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    SentryShadowActivityManager.setImportance(RunningAppProcessInfo.IMPORTANCE_CACHED)
+
+    val listenerCalls = AtomicInteger()
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartTimeSpan.setStartedAt(100)
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    // Listener set AFTER registerLifecycleCallbacks — mirrors production ordering
+    metrics.setHeadlessAppStartListener { listenerCalls.incrementAndGet() }
+    waitForMainLooperIdle()
+
+    assertEquals(AppStartMetrics.AppStartType.COLD, metrics.appStartType)
+    assertFalse(metrics.isAppLaunchedInForeground)
+    assertEquals(1, listenerCalls.get())
+  }
+
+  private fun waitForMainLooperIdle() {
+    Handler(Looper.getMainLooper()).post {}
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+  }
 }
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index e5b5ed2250b..14c8b595fd3 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -37,6 +37,15 @@
       android:exported="true"
       android:foregroundServiceType="remoteMessaging" />
 
+    <receiver
+      android:name=".TestBroadcastReceiver"
+      android:enabled="true"
+      android:exported="true">
+      <intent-filter>
+        <action android:name="io.sentry.samples.android.TEST_BROADCAST" />
+      </intent-filter>
+    </receiver>
+
     <activity
       android:name=".MainActivity"
       android:exported="true"
@@ -229,6 +238,10 @@
       android:name="io.sentry.performance-v2.enable"
       android:value="true" />
 
+    <meta-data
+      android:name="io.sentry.standalone-app-start-tracing.enable"
+      android:value="true" />
+
     <meta-data
       android:name="io.sentry.session-replay.screenshot-strategy"
       android:value="canvas" />
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TestBroadcastReceiver.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TestBroadcastReceiver.java
new file mode 100644
index 00000000000..10b4fd4d94e
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/TestBroadcastReceiver.java
@@ -0,0 +1,26 @@
+package io.sentry.samples.android;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+/**
+ * A manifest-declared broadcast receiver for testing standalone app starts.
+ *
+ * <p>Test with:
+ *
+ * <pre>{@code
+ * adb shell am force-stop io.sentry.samples.android && \
+ * adb shell am broadcast -a io.sentry.samples.android.TEST_BROADCAST \
+ *   -n io.sentry.samples.android/.TestBroadcastReceiver
+ * }</pre>
+ */
+public class TestBroadcastReceiver extends BroadcastReceiver {
+  private static final String TAG = "SentryAppStart";
+
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    Log.d(TAG, "TestBroadcastReceiver.onReceive() called - no activity will launch");
+  }
+}

From 26ddd89873d8d1bd9b1e0147fe177fd4178b1f1e Mon Sep 17 00:00:00 2001
From: Lukas Bloder <lukas.bloder@gmail.com>
Date: Mon, 15 Jun 2026 11:10:07 +0200
Subject: [PATCH 198/391] Upgrade to asyncProfiler 4.4 (#5418)

---
 CHANGELOG.md                                             | 4 ++++
 gradle/libs.versions.toml                                | 2 +-
 .../JfrAsyncProfilerToSentryProfileConverter.java        | 9 +--------
 3 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cd876f3c57d..648533ec18f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,10 @@
 
 - Reduce boxing to improve performance ([#5523](https://github.com/getsentry/sentry-java/pull/5523), [#5527](https://github.com/getsentry/sentry-java/pull/5527))
 
+### Dependencies
+
+- Upgrade to asyncProfiler 4.4 ([#5418](https://github.com/getsentry/sentry-java/pull/5418))
+
 ### Fixes
 
 - Fix performance collector scheduling many tasks in a row ([#5524](https://github.com/getsentry/sentry-java/pull/5524))
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index e653069e2b3..f6edafdc17f 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -4,7 +4,7 @@ androidxLifecycle = "2.2.0"
 androidxNavigation = "2.4.2"
 androidxTestCore = "1.7.0"
 androidxCompose = "1.6.3"
-asyncProfiler = "4.2"
+asyncProfiler = "4.4"
 composeCompiler = "1.5.14"
 coroutines = "1.6.1"
 espresso = "3.7.0"
diff --git a/sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverter.java b/sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverter.java
index b7b5662a8e5..718fae422f7 100644
--- a/sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverter.java
+++ b/sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverter.java
@@ -26,7 +26,6 @@
 
 @ApiStatus.Internal
 public final class JfrAsyncProfilerToSentryProfileConverter extends JfrConverter {
-  private static final double NANOS_PER_SECOND = 1_000_000_000.0;
   private static final long UNKNOWN_THREAD_ID = -1;
 
   private final @NotNull SentryProfile sentryProfile = new SentryProfile();
@@ -83,7 +82,6 @@ private class ProfileEventVisitor implements EventCollector.Visitor {
     private final @NotNull SentryStackTraceFactory stackTraceFactory;
     private final @NotNull JfrReader jfr;
     private final @NotNull Arguments args;
-    private final double ticksPerNanosecond;
 
     public ProfileEventVisitor(
         @NotNull SentryProfile sentryProfile,
@@ -94,7 +92,6 @@ public ProfileEventVisitor(
       this.stackTraceFactory = stackTraceFactory;
       this.jfr = jfr;
       this.args = args;
-      ticksPerNanosecond = jfr.ticksPerSec / NANOS_PER_SECOND;
     }
 
     @Override
@@ -150,11 +147,7 @@ private void processSampleWithStack(Event event, long threadId, StackTrace stack
     }
 
     private double calculateTimestamp(Event event) {
-      long nanosFromStart = (long) ((event.time - jfr.chunkStartTicks) / ticksPerNanosecond);
-
-      long timeNs = jfr.chunkStartNanos + nanosFromStart;
-
-      return DateUtils.nanosToSeconds(timeNs);
+      return DateUtils.nanosToSeconds(jfr.eventTimeToNanos(event.time));
     }
 
     private int addStackTrace(StackTrace stackTrace) {

From 77e5b0a977f40709f429b7507b8b97fc46bcbdc4 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Mon, 15 Jun 2026 11:17:04 +0200
Subject: [PATCH 199/391] chore(samples-android): Add optional SAGP build mode
 (#5538)

Adds an optional useSagp flag to Android sample app builds that, when true, applies the Sentry Android Gradle Plugin. (Defaults to false, which matches existing build behavior.)

```
./gradlew :sentry-samples:sentry-samples-android:installDebug -PuseSagp=true
```

See the Android sample app README for more details.
---
 .../sentry-samples-android/README.md          | 57 +++++++++++++++++++
 .../sentry-samples-android/build.gradle.kts   | 32 +++++++++++
 2 files changed, 89 insertions(+)
 create mode 100644 sentry-samples/sentry-samples-android/README.md

diff --git a/sentry-samples/sentry-samples-android/README.md b/sentry-samples/sentry-samples-android/README.md
new file mode 100644
index 00000000000..c7c7ad0d89c
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/README.md
@@ -0,0 +1,57 @@
+# Sentry Sample Android App
+
+Sample application demonstrating how to use the Sentry Android SDK, including core functionality (error reporting, tracing, session replay,
+profiling) and integrations (Compose, OkHttp, etc.).
+
+## How to run it?
+
+Install the app on your device or emulator:
+
+```
+./gradlew :sentry-samples:sentry-samples-android:installDebug
+```
+
+or simply open the project in Android Studio and run the `sentry-samples-android` configuration.
+
+You can also apply the [Sentry Android Gradle Plugin](https://github.com/getsentry/sentry-android-gradle-plugin) (SAGP) when building (not applied by default):
+
+```
+./gradlew :sentry-samples:sentry-samples-android:installDebug -PuseSagp=true
+```
+
+In Android Studio, add `useSagp=true` to `gradle.properties` or pass it as a Gradle project property.
+
+## Build modes
+
+### With or without SAGP
+
+The sample app can be built with or without the SAGP.
+
+| Gradle Property | Required                 | Purpose                                                                                                        |
+|-----------------|--------------------------|----------------------------------------------------------------------------------------------------------------|
+| `useSagp`       | No (defaults to `false`) | When `true`, apply SAGP when building the sample app. When false or absent, build the sample app without SAGP. |
+
+You can configure SAGP properties via the lambda passed to `extensions.configure<SentryPluginExtension>("sentry")` in the sample app's
+`build.gradle.kts` file.
+
+### Builds against your local sentry-java branch
+
+Regardless of `useSagp`, the sample always depends on sentry-java modules from this monorepo (e.g., `projects.sentryAndroid`). SAGP's SDK
+auto-installation is disabled, so the sample never pulls a separate SDK version from Maven. Local SDK changes in your branch are picked up
+directly.
+
+## Viewing SDK output
+
+### Locally
+
+Debug builds enable SDK debug logging, so captured envelopes are printed to logcat (tag `Sentry`):
+
+```
+adb logcat -s Sentry
+```
+
+### On Sentry UI
+
+By default, SDK output produced by the sample app appears under the [sentry-sdk test project](https://sentry-sdks.sentry.io/issues/?project=5428559).
+To redirect them to your own project, replace the test DSN (i.e., the `io.sentry.dsn` `meta-data` value in `src/main/AndroidManifest.xml`
+with your own.
diff --git a/sentry-samples/sentry-samples-android/build.gradle.kts b/sentry-samples/sentry-samples-android/build.gradle.kts
index ed8cea25661..44d930975ec 100644
--- a/sentry-samples/sentry-samples-android/build.gradle.kts
+++ b/sentry-samples/sentry-samples-android/build.gradle.kts
@@ -1,5 +1,7 @@
 import com.android.build.api.artifact.SingleArtifact
 import com.android.build.api.variant.impl.VariantImpl
+import io.sentry.android.gradle.extensions.InstrumentationFeature
+import io.sentry.android.gradle.extensions.SentryPluginExtension
 import org.apache.tools.ant.taskdefs.condition.Os
 import org.gradle.internal.extensions.stdlib.capitalized
 
@@ -7,6 +9,36 @@ plugins {
   id("com.android.application")
   alias(libs.plugins.kotlin.android)
   alias(libs.plugins.kotlin.compose)
+  alias(libs.plugins.sentry) apply false
+}
+
+val useSagp =
+  providers.gradleProperty("useSagp").map { it.equals("true", ignoreCase = true) }.orElse(false)
+
+if (useSagp.get()) {
+  apply(plugin = "io.sentry.android.gradle")
+}
+
+plugins.withId("io.sentry.android.gradle") {
+  // Extension configs match non-SAGP builds. Update locally to test your feature.
+  extensions.configure<SentryPluginExtension>("sentry") {
+    autoInstallation.enabled.set(false)
+    includeProguardMapping.set(false)
+    includeDependenciesReport.set(false)
+    telemetry.set(false)
+    tracingInstrumentation {
+      features.set(
+        setOf(
+          InstrumentationFeature.COMPOSE,
+          InstrumentationFeature.DATABASE,
+          InstrumentationFeature.FILE_IO,
+          InstrumentationFeature.OKHTTP,
+        )
+      )
+      logcat.enabled.set(false)
+      appStart.enabled.set(false)
+    }
+  }
 }
 
 android {

From aab75f770bf249460a877aeacdca4902d0ad8929 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Mon, 15 Jun 2026 12:18:09 +0200
Subject: [PATCH 200/391] fix(samples): allow leak canary for non-debug builds,
 so the sample app doesn't crash when using AS profiler (#5545)

---
 .../sentry-samples-android/src/main/res/values/bools.xml      | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 sentry-samples/sentry-samples-android/src/main/res/values/bools.xml

diff --git a/sentry-samples/sentry-samples-android/src/main/res/values/bools.xml b/sentry-samples/sentry-samples-android/src/main/res/values/bools.xml
new file mode 100644
index 00000000000..de1623ff077
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/res/values/bools.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <bool name="leak_canary_allow_in_non_debuggable_build">true</bool>
+</resources>

From 9d2f4e3096958e67c6acc73926f7fde9e1bf2925 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Mon, 15 Jun 2026 21:51:29 +0200
Subject: [PATCH 201/391] chore(samples-android): Support mavenLocal for builds
 that apply the SAGP (#5539)

chore(samples-android): Support mavenLocal for builds that apply the SAGP

Adds wiring that lets us prefer mavenLocal SAGP artifacts, when present, for Android sample app builds that set -PuseSagp=true. If no local artifact is found, we fall back to libs.versions.toml.
---
 gradle/libs.versions.toml                     |  3 +-
 .../sentry-samples-android/README.md          | 33 ++++++++++++++-----
 .../sentry-samples-android/build.gradle.kts   |  5 +--
 settings.gradle.kts                           | 15 +++++++--
 4 files changed, 39 insertions(+), 17 deletions(-)

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index f6edafdc17f..e7fcababd6c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -29,6 +29,7 @@ otelInstrumentationAlpha = "2.26.0-alpha"
 otelSemanticConventions = "1.40.0"
 otelSemanticConventionsAlpha = "1.40.0-alpha"
 retrofit = "2.9.0"
+sagp = "6.10.0"
 slf4j = "1.7.30"
 springboot2 = "2.7.18"
 springboot3 = "3.5.0"
@@ -66,7 +67,7 @@ springboot4 = { id = "org.springframework.boot", version.ref = "springboot4" }
 spring-dependency-management = { id = "io.spring.dependency-management", version = "1.1.7" }
 gretty = { id = "org.gretty", version = "4.0.0" }
 animalsniffer = { id = "ru.vyarus.animalsniffer", version = "2.0.1" }
-sentry = { id = "io.sentry.android.gradle", version = "6.6.0"}
+sentry = { id = "io.sentry.android.gradle", version.ref = "sagp"}
 shadow = { id = "com.gradleup.shadow", version = "9.4.1" }
 
 [libraries]
diff --git a/sentry-samples/sentry-samples-android/README.md b/sentry-samples/sentry-samples-android/README.md
index c7c7ad0d89c..f5c8caf8685 100644
--- a/sentry-samples/sentry-samples-android/README.md
+++ b/sentry-samples/sentry-samples-android/README.md
@@ -16,10 +16,10 @@ or simply open the project in Android Studio and run the `sentry-samples-android
 You can also apply the [Sentry Android Gradle Plugin](https://github.com/getsentry/sentry-android-gradle-plugin) (SAGP) when building (not applied by default):
 
 ```
-./gradlew :sentry-samples:sentry-samples-android:installDebug -PuseSagp=true
+./gradlew :sentry-samples:sentry-samples-android:installDebug -PuseSagp
 ```
 
-In Android Studio, add `useSagp=true` to `gradle.properties` or pass it as a Gradle project property.
+In Android Studio, add `useSagp=` (empty value) to `gradle.properties`, or pass `-PuseSagp` as a Gradle project property.
 
 ## Build modes
 
@@ -27,18 +27,33 @@ In Android Studio, add `useSagp=true` to `gradle.properties` or pass it as a Gra
 
 The sample app can be built with or without the SAGP.
 
-| Gradle Property | Required                 | Purpose                                                                                                        |
-|-----------------|--------------------------|----------------------------------------------------------------------------------------------------------------|
-| `useSagp`       | No (defaults to `false`) | When `true`, apply SAGP when building the sample app. When false or absent, build the sample app without SAGP. |
+| Gradle Property | Required | Purpose                                                                                         |
+|-----------------|----------|-------------------------------------------------------------------------------------------------|
+| `useSagp`       | No       | When present, apply SAGP when building the sample app. Omit the property to build without SAGP. |
 
 You can configure SAGP properties via the lambda passed to `extensions.configure<SentryPluginExtension>("sentry")` in the sample app's
 `build.gradle.kts` file.
 
-### Builds against your local sentry-java branch
+### Testing an unpublished SAGP build
 
-Regardless of `useSagp`, the sample always depends on sentry-java modules from this monorepo (e.g., `projects.sentryAndroid`). SAGP's SDK
-auto-installation is disabled, so the sample never pulls a separate SDK version from Maven. Local SDK changes in your branch are picked up
-directly.
+`-PuseSagp` builds check `mavenLocal()` first when resolving SAGP. To test a local SAGP branch:
+
+1. In your `sentry-android-gradle-plugin` checkout, temporarily set a unique local version in `plugin-build/gradle.properties` (e.g.
+   `6.10.0-LOCAL`) and publish to Maven Local:
+
+```
+./gradlew -p plugin-build publishToMavenLocal
+```
+
+Re-run `publishToMavenLocal` after each SAGP change.
+
+2. Temporarily bump the `sagp` pin in `gradle/libs.versions.toml` to match that version.
+
+Then build from sentry-java:
+
+```
+./gradlew :sentry-samples:sentry-samples-android:installDebug -PuseSagp
+```
 
 ## Viewing SDK output
 
diff --git a/sentry-samples/sentry-samples-android/build.gradle.kts b/sentry-samples/sentry-samples-android/build.gradle.kts
index 44d930975ec..e19c02700fb 100644
--- a/sentry-samples/sentry-samples-android/build.gradle.kts
+++ b/sentry-samples/sentry-samples-android/build.gradle.kts
@@ -12,10 +12,7 @@ plugins {
   alias(libs.plugins.sentry) apply false
 }
 
-val useSagp =
-  providers.gradleProperty("useSagp").map { it.equals("true", ignoreCase = true) }.orElse(false)
-
-if (useSagp.get()) {
+if (providers.gradleProperty("useSagp").isPresent) {
   apply(plugin = "io.sentry.android.gradle")
 }
 
diff --git a/settings.gradle.kts b/settings.gradle.kts
index c435c382b79..51dd84abb4f 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -1,10 +1,19 @@
 enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
 
 pluginManagement {
-    repositories {
-        mavenCentral()
-        gradlePluginPortal()
+  repositories {
+    // Prefer local SAGP artifact if one exists; otherwise fall back to libs.versions.toml.
+    if (providers.gradleProperty("useSagp").isPresent) {
+      mavenLocal {
+        content {
+          includeGroup("io.sentry")
+          includeGroup("io.sentry.android.gradle")
+        }
+      }
     }
+    mavenCentral()
+    gradlePluginPortal()
+  }
 }
 
 plugins {

From 3eb7173bf3fbd040000b90276e47f41aed8b05db Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Tue, 16 Jun 2026 08:09:41 +0200
Subject: [PATCH 202/391] feat(android-sqlite): Add SentrySQLiteDriver
 (JAVA-275) (#5466)

feat(android-sqlite): Add SentrySQLiteDriver (JAVA-275)

Introduces support for AndroidX's SQLiteDriver via a new SentrySQLiteDriver wrapper.

SentrySQLiteDriver automatically creates spans for each SQL statement it executes. Its data scheme closely tracks that of SentrySupportSQLiteOpenHelper, which it's designed to replace. (Span duration is an important exception; see the SentrySQLiteStatement KDoc for more details.)

A key motivation behind Google's use of SQLiteDriver with Room 2.7+ was Kotlin Multiplatform support. We're careful to keep the SentrySQLiteDriver KMP-compatible as well, should we one day want to lift it into sentry-kotlin-multiplatform.

---

Co-authored-by: Angus Holder <7407345+angusholder@users.noreply.github.com>
---
 gradle/libs.versions.toml                     |   2 +-
 sentry-android-sqlite/README.md               |  21 ++
 .../android/sqlite/SQLiteSpanManager.kt       |  43 +--
 .../main/java/io/sentry/sqlite/DbMetadata.kt  |  49 +++
 .../sqlite/SQLiteSpanInstrumentation.kt       |  99 ++++++
 .../sentry/sqlite/SentrySQLiteConnection.kt   |  15 +
 .../io/sentry/sqlite/SentrySQLiteDriver.kt    |  79 +++++
 .../io/sentry/sqlite/SentrySQLiteStatement.kt |  80 +++++
 .../src/test/AndroidManifest.xml              |  13 +
 .../java/io/sentry/sqlite/DbMetadataTest.kt   |  87 ++++++
 .../sqlite/SQLiteSpanInstrumentationTest.kt   | 193 ++++++++++++
 .../sqlite/SentrySQLiteConnectionTest.kt      |  63 ++++
 .../sentry/sqlite/SentrySQLiteDriverTest.kt   | 145 +++++++++
 .../sqlite/SentrySQLiteStatementTest.kt       | 291 ++++++++++++++++++
 14 files changed, 1144 insertions(+), 36 deletions(-)
 create mode 100644 sentry-android-sqlite/README.md
 create mode 100644 sentry-android-sqlite/src/main/java/io/sentry/sqlite/DbMetadata.kt
 create mode 100644 sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
 create mode 100644 sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteConnection.kt
 create mode 100644 sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
 create mode 100644 sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt
 create mode 100644 sentry-android-sqlite/src/test/AndroidManifest.xml
 create mode 100644 sentry-android-sqlite/src/test/java/io/sentry/sqlite/DbMetadataTest.kt
 create mode 100644 sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
 create mode 100644 sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteConnectionTest.kt
 create mode 100644 sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteDriverTest.kt
 create mode 100644 sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index e7fcababd6c..1ebcb8e0e38 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -95,7 +95,7 @@ androidx-lifecycle-common-java8 = { module = "androidx.lifecycle:lifecycle-commo
 androidx-lifecycle-process = { module = "androidx.lifecycle:lifecycle-process", version.ref = "androidxLifecycle" }
 androidx-navigation-runtime = { module = "androidx.navigation:navigation-runtime", version.ref = "androidxNavigation" }
 androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "androidxNavigation" }
-androidx-sqlite = { module = "androidx.sqlite:sqlite", version = "2.5.2" }
+androidx-sqlite = { module = "androidx.sqlite:sqlite", version = "2.6.2" }
 androidx-recyclerview = { module = "androidx.recyclerview:recyclerview", version = "1.2.1" }
 androidx-browser = { module = "androidx.browser:browser", version = "1.8.0" }
 async-profiler = { module = "tools.profiler:async-profiler", version.ref = "asyncProfiler" }
diff --git a/sentry-android-sqlite/README.md b/sentry-android-sqlite/README.md
new file mode 100644
index 00000000000..7bf9edf3474
--- /dev/null
+++ b/sentry-android-sqlite/README.md
@@ -0,0 +1,21 @@
+# sentry-android-sqlite
+
+SQLite instrumentation for AndroidX APIs.
+
+Two instrumentation paths are supported:
+
+- **`androidx.sqlite.SQLiteDriver`**: Used by Room 2.7+ and 3.0+.
+- **`androidx.sqlite.db.SupportSQLiteOpenHelper`**: Used by SQLDelight and legacy (pre-2.7) Room. Applied automatically by the Sentry Android Gradle Plugin.
+
+To avoid duplicate spans, only one path should be used per database file. Most Room and SQLDelight APIs enforce that division. The exception is Room's `SupportSQLiteDriver`: either the `SupportSQLiteOpenHelper` it consumes should be wrapped or the support driver itself, but never both.
+
+## Package layout
+
+The module is organized as two separate packages:
+
+- **`io.sentry.android.sqlite`**: Android-specific code. Depends on `android.database.*` and/or on `androidx.sqlite.db.*`.
+- **`io.sentry.sqlite`**: No Android-specific code. Depends only on multiplatform `androidx.sqlite.*`.
+
+The split anticipates future Kotlin Multiplatform support. The `androidx.sqlite.*` interfaces are defined in KMP's `commonMain` source set and are used by Room in non-JVM environments. Classes in `io.sentry.sqlite` are written against those portable interfaces and are intended to lift cleanly into a KMP `commonMain` source set if/when the `sentry` core gains multiplatform targets.
+
+Note that the module artifact itself (`sentry-android-sqlite`) is currently an Android-only AAR regardless of package layout.
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt
index 1bdeb7d369c..3495d3a71f0 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt
@@ -3,21 +3,17 @@ package io.sentry.android.sqlite
 import android.database.CrossProcessCursor
 import android.database.SQLException
 import io.sentry.IScopes
-import io.sentry.ISpan
-import io.sentry.Instrumenter
 import io.sentry.ScopesAdapter
 import io.sentry.SentryIntegrationPackageStorage
-import io.sentry.SentryStackTraceFactory
-import io.sentry.SpanDataConvention
 import io.sentry.SpanStatus
-
-private const val TRACE_ORIGIN = "auto.db.sqlite"
+import io.sentry.sqlite.SQLiteSpanInstrumentation
 
 internal class SQLiteSpanManager(
   private val scopes: IScopes = ScopesAdapter.getInstance(),
-  private val databaseName: String? = null,
+  databaseName: String? = null,
 ) {
-  private val stackTraceFactory = SentryStackTraceFactory(scopes.options)
+
+  private val spans = SQLiteSpanInstrumentation.fromDatabaseName(databaseName, scopes)
 
   init {
     SentryIntegrationPackageStorage.getInstance().addIntegration("SQLite")
@@ -33,8 +29,8 @@ internal class SQLiteSpanManager(
   @Suppress("TooGenericExceptionCaught", "UNCHECKED_CAST")
   @Throws(SQLException::class)
   fun <T> performSql(sql: String, operation: () -> T): T {
-    val startTimestamp = scopes.getOptions().dateProvider.now()
-    var span: ISpan? = null
+    val startTimestamp = spans.startTimestamp()
+
     return try {
       val result = operation()
       /*
@@ -45,34 +41,11 @@ internal class SQLiteSpanManager(
       if (result is CrossProcessCursor) {
         return SentryCrossProcessCursor(result, this, sql) as T
       }
-      span = scopes.span?.startChild("db.sql.query", sql, startTimestamp, Instrumenter.SENTRY)
-      span?.spanContext?.origin = TRACE_ORIGIN
-      span?.status = SpanStatus.OK
+      spans.recordSpan(sql, startTimestamp, SpanStatus.OK)
       result
     } catch (e: Throwable) {
-      span = scopes.span?.startChild("db.sql.query", sql, startTimestamp, Instrumenter.SENTRY)
-      span?.spanContext?.origin = TRACE_ORIGIN
-      span?.status = SpanStatus.INTERNAL_ERROR
-      span?.throwable = e
+      spans.recordSpan(sql, startTimestamp, SpanStatus.INTERNAL_ERROR, e)
       throw e
-    } finally {
-      span?.apply {
-        val isMainThread: Boolean = scopes.options.threadChecker.isMainThread
-        setData(SpanDataConvention.BLOCKED_MAIN_THREAD_KEY, isMainThread)
-        if (isMainThread) {
-          setData(SpanDataConvention.CALL_STACK_KEY, stackTraceFactory.inAppCallStack)
-        }
-        // if db name is null, then it's an in-memory database as per
-        // https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:sqlite/sqlite/src/main/java/androidx/sqlite/db/SupportSQLiteOpenHelper.kt;l=38-42
-        if (databaseName != null) {
-          setData(SpanDataConvention.DB_SYSTEM_KEY, "sqlite")
-          setData(SpanDataConvention.DB_NAME_KEY, databaseName)
-        } else {
-          setData(SpanDataConvention.DB_SYSTEM_KEY, "in-memory")
-        }
-
-        finish()
-      }
     }
   }
 }
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/DbMetadata.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/DbMetadata.kt
new file mode 100644
index 00000000000..aa3c186b6d9
--- /dev/null
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/DbMetadata.kt
@@ -0,0 +1,49 @@
+package io.sentry.sqlite
+
+/** [DB_SYSTEM_KEY][io.sentry.SpanDataConvention.DB_SYSTEM_KEY] value for in-memory databases. */
+internal const val DB_SYSTEM_IN_MEMORY = "in-memory"
+
+/** [DB_SYSTEM_KEY][io.sentry.SpanDataConvention.DB_SYSTEM_KEY] value for SQLite databases. */
+internal const val DB_SYSTEM_SQLITE = "sqlite"
+
+/**
+ * Sentinel file name that [SQLiteDriver.open][androidx.sqlite.SQLiteDriver.open] interprets as an
+ * in-memory database (see docs
+ * [here](https://developer.android.com/reference/androidx/sqlite/driver/AndroidSQLiteDriver)).
+ */
+private const val IN_MEMORY_DB_FILENAME = ":memory:"
+
+/** Path separators matching [File.separatorChar][java.io.File.separatorChar]. */
+private val FILE_NAME_PATH_SEPARATORS = charArrayOf('/', '\\')
+
+internal data class DbMetadata(val name: String?, val system: String)
+
+/**
+ * Returns metadata based on the [fileName] argument passed to
+ * [SQLiteDriver.open][androidx.sqlite.SQLiteDriver.open].
+ */
+internal fun dbMetadataFromFileName(fileName: String): DbMetadata {
+  if (fileName == IN_MEMORY_DB_FILENAME) {
+    return DbMetadata(name = null, system = DB_SYSTEM_IN_MEMORY)
+  }
+
+  val trimmed = fileName.trimEnd { it in FILE_NAME_PATH_SEPARATORS }
+  if (trimmed.isEmpty()) {
+    return DbMetadata(name = null, system = DB_SYSTEM_SQLITE)
+  }
+
+  val index = trimmed.lastIndexOfAny(FILE_NAME_PATH_SEPARATORS)
+  val basename = if (index >= 0) trimmed.substring(index + 1) else trimmed
+  return DbMetadata(name = basename.ifEmpty { null }, system = DB_SYSTEM_SQLITE)
+}
+
+/**
+ * Returns metadata based on
+ * [SupportSQLiteOpenHelper.databaseName][androidx.sqlite.db.SupportSQLiteOpenHelper.databaseName].
+ */
+internal fun dbMetadataFromDatabaseName(databaseName: String?): DbMetadata =
+  if (databaseName == null) {
+    DbMetadata(name = null, system = DB_SYSTEM_IN_MEMORY)
+  } else {
+    DbMetadata(name = databaseName, system = DB_SYSTEM_SQLITE)
+  }
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
new file mode 100644
index 00000000000..4c925198bd5
--- /dev/null
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
@@ -0,0 +1,99 @@
+package io.sentry.sqlite
+
+import io.sentry.IScopes
+import io.sentry.Instrumenter
+import io.sentry.ScopesAdapter
+import io.sentry.SentryDate
+import io.sentry.SentryLongDate
+import io.sentry.SentryStackTraceFactory
+import io.sentry.SpanDataConvention
+import io.sentry.SpanStatus
+
+private const val SQLITE_TRACE_ORIGIN = "auto.db.sqlite"
+
+/** Shared span instrumentation for SQLite. */
+internal class SQLiteSpanInstrumentation(
+  private val scopes: IScopes,
+  private val dbMetadata: DbMetadata,
+) {
+
+  private val stackTraceFactory = SentryStackTraceFactory(scopes.options)
+
+  /**
+   * Returns a start timestamp for a `db.sql.query` span.
+   *
+   * Exposed so callers can capture a wall-clock start before accumulating database time.
+   * Internalizing the start time in [recordSpan] would shift spans to end-of-work on the trace
+   * timeline, which is less desirable.
+   */
+  fun startTimestamp(): SentryDate = scopes.options.dateProvider.now()
+
+  /** Records a `db.sql.query` span from [startTimestamp] to the moment of invocation. */
+  fun recordSpan(
+    sql: String,
+    startTimestamp: SentryDate,
+    status: SpanStatus,
+    throwable: Throwable? = null,
+  ) {
+    recordSpan(sql, startTimestamp, endTimestamp = null, status, throwable)
+  }
+
+  /** Records a `db.sql.query` span from [startTimestamp] to [startTimestamp] + [durationNanos]. */
+  fun recordSpan(
+    sql: String,
+    startTimestamp: SentryDate,
+    durationNanos: Long,
+    status: SpanStatus,
+    throwable: Throwable? = null,
+  ) {
+    val endTimestamp = SentryLongDate(startTimestamp.nanoTimestamp() + durationNanos)
+    recordSpan(sql, startTimestamp, endTimestamp, status, throwable)
+  }
+
+  private fun recordSpan(
+    sql: String,
+    startTimestamp: SentryDate,
+    endTimestamp: SentryDate?,
+    status: SpanStatus,
+    throwable: Throwable?,
+  ) {
+    scopes.span?.startChild("db.sql.query", sql, startTimestamp, Instrumenter.SENTRY)?.apply {
+      spanContext.origin = SQLITE_TRACE_ORIGIN
+      throwable?.let { this.throwable = it }
+
+      val isMainThread = scopes.options.threadChecker.isMainThread
+      setData(SpanDataConvention.BLOCKED_MAIN_THREAD_KEY, isMainThread)
+
+      if (isMainThread) {
+        setData(SpanDataConvention.CALL_STACK_KEY, stackTraceFactory.inAppCallStack)
+      }
+
+      dbMetadata.name?.let { setData(SpanDataConvention.DB_NAME_KEY, it) }
+      setData(SpanDataConvention.DB_SYSTEM_KEY, dbMetadata.system)
+      finish(status, endTimestamp)
+    }
+  }
+
+  companion object {
+
+    /**
+     * Returns [SQLiteSpanInstrumentation] based on the [fileName] argument passed to
+     * [SQLiteDriver.open][androidx.sqlite.SQLiteDriver.open].
+     */
+    fun fromFileName(
+      fileName: String,
+      scopes: IScopes = ScopesAdapter.getInstance(),
+    ): SQLiteSpanInstrumentation =
+      SQLiteSpanInstrumentation(scopes, dbMetadataFromFileName(fileName))
+
+    /**
+     * Returns [SQLiteSpanInstrumentation] based on
+     * [SupportSQLiteOpenHelper.databaseName][androidx.sqlite.db.SupportSQLiteOpenHelper.databaseName].
+     */
+    fun fromDatabaseName(
+      databaseName: String?,
+      scopes: IScopes = ScopesAdapter.getInstance(),
+    ): SQLiteSpanInstrumentation =
+      SQLiteSpanInstrumentation(scopes, dbMetadataFromDatabaseName(databaseName))
+  }
+}
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteConnection.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteConnection.kt
new file mode 100644
index 00000000000..45ee9a39b27
--- /dev/null
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteConnection.kt
@@ -0,0 +1,15 @@
+package io.sentry.sqlite
+
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.SQLiteStatement
+
+internal class SentrySQLiteConnection(
+  private val delegate: SQLiteConnection,
+  private val spans: SQLiteSpanInstrumentation,
+) : SQLiteConnection by delegate {
+
+  override fun prepare(sql: String): SQLiteStatement {
+    val statement = delegate.prepare(sql)
+    return statement as? SentrySQLiteStatement ?: SentrySQLiteStatement(statement, spans, sql)
+  }
+}
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
new file mode 100644
index 00000000000..9a619c418a5
--- /dev/null
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
@@ -0,0 +1,79 @@
+package io.sentry.sqlite
+
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.SQLiteDriver
+import io.sentry.ScopesAdapter
+import io.sentry.SentryIntegrationPackageStorage
+import io.sentry.SentryLevel
+
+/**
+ * Wraps a [SQLiteDriver] and automatically adds spans for each SQL statement it executes.
+ *
+ * Example usage:
+ * ```
+ * val driver = SentrySQLiteDriver.create(AndroidSQLiteDriver())
+ * ```
+ *
+ * If you use Room:
+ * ```
+ * val database = Room.databaseBuilder(context, MyDatabase::class.java, "dbName")
+ *     .setDriver(SentrySQLiteDriver.create(AndroidSQLiteDriver()))
+ *     .build()
+ * ```
+ *
+ * **Warning:** Do not use [SentrySQLiteDriver] together with
+ * [SentrySupportSQLiteOpenHelper][io.sentry.android.sqlite.SentrySupportSQLiteOpenHelper] on the
+ * same database file. Both wrappers instrument at different layers and combining them will produce
+ * duplicate spans.
+ *
+ * @param delegate The [SQLiteDriver] instance to delegate calls to.
+ */
+internal class SentrySQLiteDriver private constructor(private val delegate: SQLiteDriver) :
+  SQLiteDriver {
+
+  init {
+    SentryIntegrationPackageStorage.getInstance().addIntegration("SQLiteDriver")
+  }
+
+  override val hasConnectionPool: Boolean
+    get() =
+      try {
+        delegate.hasConnectionPool
+      } catch (_: LinkageError) {
+        // Delegates on androidx.sqlite < 2.6.0 won't have a hasConnectionPool property.
+        false
+      }
+
+  @Suppress("TooGenericExceptionCaught")
+  override fun open(fileName: String): SQLiteConnection {
+    val connection = delegate.open(fileName)
+
+    return try {
+      val spans = SQLiteSpanInstrumentation.fromFileName(fileName)
+      // create() ensures delegate is unwrapped, so we don't need to protect against double-wrapping
+      // the connection.
+      SentrySQLiteConnection(connection, spans)
+    } catch (t: Throwable) {
+      ScopesAdapter.getInstance()
+        .options
+        .logger
+        .log(
+          SentryLevel.ERROR,
+          "Failed to instrument SQLite connection; returning uninstrumented connection.",
+          t,
+        )
+      connection
+    }
+  }
+
+  companion object {
+
+    /**
+     * Wraps the provided delegate in a [SentrySQLiteDriver]. Returns the delegate as-is if already
+     * wrapped.
+     */
+    @JvmStatic
+    fun create(delegate: SQLiteDriver): SQLiteDriver =
+      delegate as? SentrySQLiteDriver ?: SentrySQLiteDriver(delegate)
+  }
+}
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt
new file mode 100644
index 00000000000..41df37444b5
--- /dev/null
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt
@@ -0,0 +1,80 @@
+package io.sentry.sqlite
+
+import androidx.sqlite.SQLiteStatement
+import io.sentry.SentryDate
+import io.sentry.SpanStatus
+
+/**
+ * Wraps a [SQLiteStatement] and records a single Sentry span covering all [step] calls for the
+ * statement's lifetime (until [step] iteration is complete or the statement is [reset] or
+ * [closed][close]).
+ *
+ * Span duration is restricted to accumulated database time, i.e., each [step] call is individually
+ * timed and the durations are summed. Time the application spends between steps (e.g., processing
+ * rows, sleeping, or doing I/O) is intentionally excluded.
+ *
+ * Not thread-safe: assumes sequential access within each SQL statement (normal SQLite usage).
+ */
+internal class SentrySQLiteStatement(
+  private val delegate: SQLiteStatement,
+  private val spans: SQLiteSpanInstrumentation,
+  private val sql: String,
+  private val nanoTimeProvider: () -> Long = { System.nanoTime() },
+) : SQLiteStatement by delegate {
+
+  private var firstStepTimestamp: SentryDate? = null
+  private var accumulatedDbNanos: Long = 0L
+  private var stepsComplete = false
+  private var closed = false
+
+  @Suppress("TooGenericExceptionCaught")
+  override fun step(): Boolean {
+    if (stepsComplete || closed) {
+      return delegate.step()
+    }
+
+    val beforeNanos = nanoTimeProvider()
+    return try {
+      if (firstStepTimestamp == null) {
+        firstStepTimestamp = spans.startTimestamp()
+      }
+
+      stepsComplete = !delegate.step()
+      accumulatedDbNanos += nanoTimeProvider() - beforeNanos
+      if (stepsComplete) {
+        recordSpan(SpanStatus.OK)
+      }
+      !stepsComplete
+    } catch (e: Throwable) {
+      accumulatedDbNanos += nanoTimeProvider() - beforeNanos
+      recordSpan(SpanStatus.INTERNAL_ERROR, e)
+      throw e
+    }
+  }
+
+  override fun reset() {
+    if (closed) {
+      return delegate.reset()
+    }
+
+    try {
+      recordSpan(SpanStatus.OK)
+    } finally {
+      delegate.reset()
+      stepsComplete = false
+    }
+  }
+
+  override fun close() {
+    closed = true
+    delegate.use { recordSpan(SpanStatus.OK) }
+  }
+
+  private fun recordSpan(status: SpanStatus, throwable: Throwable? = null) {
+    val start = firstStepTimestamp ?: return
+    val duration = accumulatedDbNanos
+    firstStepTimestamp = null
+    accumulatedDbNanos = 0L
+    spans.recordSpan(sql, start, duration, status, throwable)
+  }
+}
diff --git a/sentry-android-sqlite/src/test/AndroidManifest.xml b/sentry-android-sqlite/src/test/AndroidManifest.xml
new file mode 100644
index 00000000000..967265a1f16
--- /dev/null
+++ b/sentry-android-sqlite/src/test/AndroidManifest.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:tools="http://schemas.android.com/tools">
+
+  <!-- androidx.sqlite 2.6.0+ raised minSdk to 23; this module still targets 21. -->
+  <uses-sdk
+      tools:overrideLibrary="
+          androidx.sqlite.db,
+          androidx.sqlite.db.framework,
+          androidx.sqlite.driver.bundled,
+          androidx.sqlite.sqlite.anchor,
+          androidx.sqlite.sqlite.bundled.anchor,
+          androidx.sqlite.sqlite.framework.anchor" />
+</manifest>
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/DbMetadataTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/DbMetadataTest.kt
new file mode 100644
index 00000000000..227b9d9558c
--- /dev/null
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/DbMetadataTest.kt
@@ -0,0 +1,87 @@
+package io.sentry.sqlite
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+class DbMetadataTest {
+
+  @Test
+  fun `dbMetadataFromFileName returns in-memory system with no db name for in-memory sentinel`() {
+    assertEquals(
+      DbMetadata(name = null, system = DB_SYSTEM_IN_MEMORY),
+      dbMetadataFromFileName(":memory:"),
+    )
+  }
+
+  @Test
+  fun `dbMetadataFromDatabaseName returns in-memory system with no db name when databaseName is null`() {
+    assertEquals(
+      DbMetadata(name = null, system = DB_SYSTEM_IN_MEMORY),
+      dbMetadataFromDatabaseName(null),
+    )
+  }
+
+  @Test
+  fun `dbMetadataFromFileName returns sqlite system and db name for unix path`() {
+    assertEquals(
+      DbMetadata(name = "tracks.db", system = DB_SYSTEM_SQLITE),
+      dbMetadataFromFileName("/data/data/com.example/databases/tracks.db"),
+    )
+  }
+
+  @Test
+  fun `dbMetadataFromFileName returns sqlite system and db name when fileName has no separator`() {
+    assertEquals(
+      DbMetadata(name = "tracks", system = DB_SYSTEM_SQLITE),
+      dbMetadataFromFileName("tracks"),
+    )
+    assertEquals(
+      DbMetadata(name = "tracks.db", system = DB_SYSTEM_SQLITE),
+      dbMetadataFromFileName("tracks.db"),
+    )
+  }
+
+  @Test
+  fun `dbMetadataFromFileName returns sqlite system and db name for relative path with forward slashes`() {
+    assertEquals(
+      DbMetadata(name = "myapp.db", system = DB_SYSTEM_SQLITE),
+      dbMetadataFromFileName("databases/myapp.db"),
+    )
+  }
+
+  @Test
+  fun `dbMetadataFromFileName returns sqlite system and db name for windows-style path`() {
+    assertEquals(
+      DbMetadata(name = "myapp.db", system = DB_SYSTEM_SQLITE),
+      dbMetadataFromFileName("C:\\Users\\app\\databases\\myapp.db"),
+    )
+  }
+
+  @Test
+  fun `dbMetadataFromFileName uses last separator when both slash types are present`() {
+    assertEquals(
+      DbMetadata(name = "db.sqlite", system = DB_SYSTEM_SQLITE),
+      dbMetadataFromFileName("/data\\mixed/path\\db.sqlite"),
+    )
+  }
+
+  @Test
+  fun `dbMetadataFromFileName returns sqlite system and db name when fileName ends with separator`() {
+    assertEquals(
+      DbMetadata(name = "databases", system = DB_SYSTEM_SQLITE),
+      dbMetadataFromFileName("/data/data/com.example/databases/"),
+    )
+  }
+
+  @Test
+  fun `dbMetadataFromFileName returns sqlite system and unknown db name when fileName contains only separators`() {
+    assertEquals(DbMetadata(name = null, system = DB_SYSTEM_SQLITE), dbMetadataFromFileName("/"))
+    assertEquals(DbMetadata(name = null, system = DB_SYSTEM_SQLITE), dbMetadataFromFileName("///"))
+    assertEquals(DbMetadata(name = null, system = DB_SYSTEM_SQLITE), dbMetadataFromFileName("\\\\"))
+  }
+
+  @Test
+  fun `dbMetadataFromFileName returns sqlite system and unknown db name for empty fileName`() {
+    assertEquals(DbMetadata(name = null, system = DB_SYSTEM_SQLITE), dbMetadataFromFileName(""))
+  }
+}
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
new file mode 100644
index 00000000000..ead123a190b
--- /dev/null
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
@@ -0,0 +1,193 @@
+package io.sentry.sqlite
+
+import io.sentry.IScopes
+import io.sentry.SentryOptions
+import io.sentry.SentryTracer
+import io.sentry.SpanDataConvention
+import io.sentry.SpanStatus
+import io.sentry.TransactionContext
+import io.sentry.util.thread.IThreadChecker
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+class SQLiteSpanInstrumentationTest {
+
+  private class Fixture {
+
+    val scopes = mock<IScopes>()
+    lateinit var sentryTracer: SentryTracer
+    lateinit var options: SentryOptions
+
+    fun getSut(
+      isTransactionActive: Boolean = true,
+      fileName: String = ":memory:",
+    ): SQLiteSpanInstrumentation {
+      options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
+      whenever(scopes.options).thenReturn(options)
+      sentryTracer = SentryTracer(TransactionContext("name", "op"), scopes)
+      if (isTransactionActive) {
+        whenever(scopes.span).thenReturn(sentryTracer)
+      }
+      return SQLiteSpanInstrumentation.fromFileName(fileName, scopes)
+    }
+  }
+
+  private val fixture = Fixture()
+
+  @Test
+  fun `recordSpan records a span if a transaction is active`() {
+    val sut = fixture.getSut(isTransactionActive = true)
+    sut.recordSpan("SELECT 1", sut.startTimestamp(), 1_000_000, SpanStatus.OK)
+    assertEquals(1, fixture.sentryTracer.children.size)
+  }
+
+  @Test
+  fun `recordSpan does not record a span if no transaction is active`() {
+    val sut = fixture.getSut(isTransactionActive = false)
+    val start = sut.startTimestamp()
+    sut.recordSpan("SELECT 1", start, 1_000_000, SpanStatus.OK)
+    assertEquals(0, fixture.sentryTracer.children.size)
+  }
+
+  @Test
+  fun `recordSpan creates a span with correct properties`() {
+    val sut = fixture.getSut()
+    val start = sut.startTimestamp()
+    sut.recordSpan("SELECT * FROM users", start, 1_000_000, SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.firstOrNull()
+    assertNotNull(span)
+    assertEquals("db.sql.query", span.operation)
+    assertEquals("SELECT * FROM users", span.description)
+    assertEquals("auto.db.sqlite", span.spanContext.origin)
+    assertEquals(SpanStatus.OK, span.status)
+    assertTrue(span.isFinished)
+  }
+
+  @Test
+  fun `recordSpan sets finishDate equal to startDate + durationNanos`() {
+    val sut = fixture.getSut()
+    val start = sut.startTimestamp()
+    val durationNanos = 42_000_000L
+
+    sut.recordSpan("SELECT 1", start, durationNanos, SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.first()
+    assertEquals(start, span.startDate)
+    assertEquals(span.startDate.nanoTimestamp() + durationNanos, span.finishDate!!.nanoTimestamp())
+  }
+
+  @Test
+  fun `recordSpan attaches throwable when provided`() {
+    val sut = fixture.getSut()
+    val start = sut.startTimestamp()
+    val exception = RuntimeException("disk I/O error")
+
+    sut.recordSpan("INSERT INTO t VALUES(1)", start, 500_000, SpanStatus.INTERNAL_ERROR, exception)
+
+    val span = fixture.sentryTracer.children.first()
+    assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
+    assertEquals(exception, span.throwable)
+  }
+
+  @Test
+  fun `recordSpan sets db system and db name when fileName is not the in-memory sentinel`() {
+    val sut = fixture.getSut(fileName = "/data/data/com.example/databases/tracks.db")
+    val start = sut.startTimestamp()
+    sut.recordSpan("SELECT 1", start, 1_000_000, SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.first()
+    assertEquals("sqlite", span.data[SpanDataConvention.DB_SYSTEM_KEY])
+    assertEquals("tracks.db", span.data[SpanDataConvention.DB_NAME_KEY])
+  }
+
+  @Test
+  fun `recordSpan sets db system only when fileName is the in-memory sentinel`() {
+    val sut = fixture.getSut(fileName = ":memory:")
+    val start = sut.startTimestamp()
+    sut.recordSpan("SELECT 1", start, 1_000_000, SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.first()
+    assertEquals("in-memory", span.data[SpanDataConvention.DB_SYSTEM_KEY])
+    assertNull(span.data[SpanDataConvention.DB_NAME_KEY])
+  }
+
+  @Test
+  fun `recordSpan sets blocked_main_thread to true and attaches call stack on main thread`() {
+    val sut = fixture.getSut()
+    fixture.options.threadChecker = mock<IThreadChecker>()
+    whenever(fixture.options.threadChecker.isMainThread).thenReturn(true)
+    whenever(fixture.options.threadChecker.currentThreadName).thenReturn("main")
+
+    sut.recordSpan("SELECT 1", sut.startTimestamp(), 1_000_000, SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.first()
+    assertTrue(span.getData(SpanDataConvention.BLOCKED_MAIN_THREAD_KEY) as Boolean)
+    assertNotNull(span.getData(SpanDataConvention.CALL_STACK_KEY))
+  }
+
+  @Test
+  fun `recordSpan sets blocked_main_thread to false and does not attach a call stack on background thread`() {
+    val sut = fixture.getSut()
+    fixture.options.threadChecker = mock<IThreadChecker>()
+    whenever(fixture.options.threadChecker.isMainThread).thenReturn(false)
+    whenever(fixture.options.threadChecker.currentThreadName).thenReturn("worker")
+
+    sut.recordSpan("SELECT 1", sut.startTimestamp(), 1_000_000, SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.first()
+    assertFalse(span.getData(SpanDataConvention.BLOCKED_MAIN_THREAD_KEY) as Boolean)
+    assertNull(span.getData(SpanDataConvention.CALL_STACK_KEY))
+  }
+
+  @Test
+  fun `recordSpan without a duration finishes the span at the time of invocation`() {
+    val sut = fixture.getSut()
+    val start = sut.startTimestamp()
+
+    sut.recordSpan("SELECT 1", start, SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.first()
+    assertTrue(span.isFinished)
+    assertEquals(SpanStatus.OK, span.status)
+    // Unlike the duration overload, no synthetic end timestamp is supplied; the span finishes at
+    // "now", i.e. at or after its start.
+    assertTrue(span.finishDate!!.nanoTimestamp() >= start.nanoTimestamp())
+  }
+
+  @Test
+  fun `fromFileName sets db name from fileName`() {
+    val options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
+    whenever(fixture.scopes.options).thenReturn(options)
+    fixture.sentryTracer = SentryTracer(TransactionContext("name", "op"), fixture.scopes)
+    whenever(fixture.scopes.span).thenReturn(fixture.sentryTracer)
+
+    val sut = SQLiteSpanInstrumentation.fromFileName("tracks.db", fixture.scopes)
+    sut.recordSpan("SELECT 1", sut.startTimestamp(), SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.first()
+    assertEquals("sqlite", span.data[SpanDataConvention.DB_SYSTEM_KEY])
+    assertEquals("tracks.db", span.data[SpanDataConvention.DB_NAME_KEY])
+  }
+
+  @Test
+  fun `fromDatabaseName sets db name from databaseName`() {
+    val options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
+    whenever(fixture.scopes.options).thenReturn(options)
+    fixture.sentryTracer = SentryTracer(TransactionContext("name", "op"), fixture.scopes)
+    whenever(fixture.scopes.span).thenReturn(fixture.sentryTracer)
+
+    val sut = SQLiteSpanInstrumentation.fromDatabaseName("tracks.db", fixture.scopes)
+    sut.recordSpan("SELECT 1", sut.startTimestamp(), SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.first()
+    assertEquals("sqlite", span.data[SpanDataConvention.DB_SYSTEM_KEY])
+    assertEquals("tracks.db", span.data[SpanDataConvention.DB_NAME_KEY])
+  }
+}
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteConnectionTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteConnectionTest.kt
new file mode 100644
index 00000000000..b405d054f03
--- /dev/null
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteConnectionTest.kt
@@ -0,0 +1,63 @@
+package io.sentry.sqlite
+
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.SQLiteStatement
+import io.sentry.IScopes
+import io.sentry.SentryOptions
+import kotlin.test.Test
+import kotlin.test.assertIs
+import kotlin.test.assertSame
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class SentrySQLiteConnectionTest {
+
+  private class Fixture {
+
+    val scopes = mock<IScopes>()
+    val mockConnection = mock<SQLiteConnection>()
+    val mockStatement = mock<SQLiteStatement>()
+    lateinit var options: SentryOptions
+
+    fun getSut(): SentrySQLiteConnection {
+      options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
+      whenever(scopes.options).thenReturn(options)
+      whenever(mockConnection.prepare("SELECT 1")).thenReturn(mockStatement)
+      val spans = SQLiteSpanInstrumentation.fromFileName("test.db", scopes)
+      return SentrySQLiteConnection(mockConnection, spans)
+    }
+  }
+
+  private val fixture = Fixture()
+
+  @Test
+  fun `prepare returns a SentrySQLiteStatement`() {
+    val sut = fixture.getSut()
+    val statement = sut.prepare("SELECT 1")
+    assertIs<SentrySQLiteStatement>(statement)
+  }
+
+  @Test
+  fun `prepare with already-wrapped statement returns same instance without re-wrapping`() {
+    val sut = fixture.getSut()
+    val spans = SQLiteSpanInstrumentation.fromFileName("test.db", fixture.scopes)
+    val alreadyInstrumented = SentrySQLiteStatement(fixture.mockStatement, spans, "SELECT 1")
+    whenever(fixture.mockConnection.prepare("SELECT 1")).thenReturn(alreadyInstrumented)
+
+    val statement = sut.prepare("SELECT 1")
+
+    assertSame(alreadyInstrumented, statement)
+  }
+
+  @Test
+  fun `all calls are propagated to the delegate`() {
+    val sut = fixture.getSut()
+
+    sut.prepare("SELECT 1")
+    verify(fixture.mockConnection).prepare("SELECT 1")
+
+    sut.close()
+    verify(fixture.mockConnection).close()
+  }
+}
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteDriverTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteDriverTest.kt
new file mode 100644
index 00000000000..9b2345a975f
--- /dev/null
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteDriverTest.kt
@@ -0,0 +1,145 @@
+package io.sentry.sqlite
+
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.SQLiteDriver
+import androidx.sqlite.SQLiteStatement
+import io.sentry.IScopes
+import io.sentry.Sentry
+import io.sentry.SentryIntegrationPackageStorage
+import io.sentry.SentryOptions
+import io.sentry.SentryTracer
+import io.sentry.SpanDataConvention
+import io.sentry.TransactionContext
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlin.test.assertFalse
+import kotlin.test.assertIs
+import kotlin.test.assertNotNull
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.junit.Before
+import org.mockito.Mockito
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class SentrySQLiteDriverTest {
+
+  private class Fixture {
+
+    val mockDriver = mock<SQLiteDriver>()
+    val mockConnection = mock<SQLiteConnection>()
+
+    fun getSut(fileName: String): SentrySQLiteDriver {
+      whenever(mockDriver.open(fileName)).thenReturn(mockConnection)
+      return SentrySQLiteDriver.create(mockDriver) as SentrySQLiteDriver
+    }
+  }
+
+  private val fixture = Fixture()
+
+  @Before
+  fun setup() {
+    SentryIntegrationPackageStorage.getInstance().clearStorage()
+  }
+
+  @Test
+  fun `create registers SQLiteDriver integration`() {
+    assertFalse(SentryIntegrationPackageStorage.getInstance().integrations.contains("SQLiteDriver"))
+    SentrySQLiteDriver.create(fixture.mockDriver)
+    assertTrue(SentryIntegrationPackageStorage.getInstance().integrations.contains("SQLiteDriver"))
+  }
+
+  @Test
+  fun `create with non-wrapped driver returns SentrySQLiteDriver`() {
+    val result = SentrySQLiteDriver.create(fixture.mockDriver)
+    assertIs<SentrySQLiteDriver>(result)
+  }
+
+  @Test
+  fun `create with already-wrapped driver returns same instance without re-wrapping`() {
+    val wrapped = SentrySQLiteDriver.create(fixture.mockDriver)
+    val doubleWrapped = SentrySQLiteDriver.create(wrapped)
+    assertSame(wrapped, doubleWrapped)
+  }
+
+  @Test
+  fun `hasConnectionPool forwards delegate value when supported`() {
+    whenever(fixture.mockDriver.hasConnectionPool).thenReturn(true)
+    val sut = SentrySQLiteDriver.create(fixture.mockDriver) as SentrySQLiteDriver
+    assertTrue(sut.hasConnectionPool)
+  }
+
+  @Test
+  fun `hasConnectionPool returns false when delegate throws LinkageError`() {
+    whenever(fixture.mockDriver.hasConnectionPool).thenThrow(AbstractMethodError())
+    val sut = SentrySQLiteDriver.create(fixture.mockDriver) as SentrySQLiteDriver
+    assertFalse(sut.hasConnectionPool)
+  }
+
+  @Test
+  fun `hasConnectionPool does not catch non-LinkageErrors`() {
+    whenever(fixture.mockDriver.hasConnectionPool).thenThrow(IllegalStateException())
+    val sut = SentrySQLiteDriver.create(fixture.mockDriver) as SentrySQLiteDriver
+    assertFailsWith<IllegalStateException> { sut.hasConnectionPool }
+  }
+
+  @Test
+  fun `open returns SentrySQLiteConnection wrapping delegate if wrapping succeeds`() {
+    val driver = fixture.getSut("myapp.db")
+    val connection = driver.open("myapp.db")
+    assertIs<SentrySQLiteConnection>(connection)
+  }
+
+  @Test
+  fun `open returns the unwrapped delegate if wrapping fails`() {
+    val brokenScopes = mock<IScopes>()
+    val validOptions = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
+    whenever(brokenScopes.options)
+      .thenThrow(RuntimeException("Sentry options unavailable"))
+      .thenReturn(validOptions)
+
+    Mockito.mockStatic(Sentry::class.java).use { mockedSentry ->
+      mockedSentry.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(brokenScopes)
+
+      val driver = fixture.getSut("myapp.db")
+      val result = driver.open("myapp.db")
+
+      assertSame(fixture.mockConnection, result)
+      verify(fixture.mockDriver).open("myapp.db")
+    }
+  }
+
+  // Smoke test ensuring all layers are properly wired up.
+  @Test
+  fun `full stack produces a span with correct metadata`() {
+    val scopes = mock<IScopes>()
+    val options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
+    whenever(scopes.options).thenReturn(options)
+    val tracer = SentryTracer(TransactionContext("name", "op"), scopes)
+    whenever(scopes.span).thenReturn(tracer)
+
+    val mockStatement = mock<SQLiteStatement>()
+    whenever(fixture.mockConnection.prepare("SELECT * FROM users")).thenReturn(mockStatement)
+    whenever(mockStatement.step()).thenReturn(true, false)
+
+    Mockito.mockStatic(Sentry::class.java).use { mockedSentry ->
+      mockedSentry.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(scopes)
+
+      val driver = fixture.getSut("/data/data/com.example/databases/myapp.db")
+      val connection = driver.open("/data/data/com.example/databases/myapp.db")
+      val statement = connection.prepare("SELECT * FROM users")
+
+      assertIs<SentrySQLiteConnection>(connection)
+      assertIs<SentrySQLiteStatement>(statement)
+
+      statement.step()
+      statement.step()
+
+      val span = tracer.children.firstOrNull()
+      assertNotNull(span)
+      assertEquals("myapp.db", span.data[SpanDataConvention.DB_NAME_KEY])
+    }
+  }
+}
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt
new file mode 100644
index 00000000000..6691910e358
--- /dev/null
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt
@@ -0,0 +1,291 @@
+package io.sentry.sqlite
+
+import androidx.sqlite.SQLiteStatement
+import io.sentry.SentryLongDate
+import io.sentry.SpanStatus
+import java.util.concurrent.atomic.AtomicLong
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.anyOrNull
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class SentrySQLiteStatementTest {
+
+  private class Fixture {
+    val mockStatement = mock<SQLiteStatement>()
+    val mockSpans = mock<SQLiteSpanInstrumentation>()
+    val startDate = SentryLongDate(1_000_000_000_000L)
+    val fakeClock = AtomicLong(0L)
+
+    fun getSut(sql: String): SentrySQLiteStatement {
+      whenever(mockSpans.startTimestamp()).thenReturn(startDate)
+      return SentrySQLiteStatement(mockStatement, mockSpans, sql, fakeClock::getAndIncrement)
+    }
+  }
+
+  private val fixture = Fixture()
+
+  @Test
+  fun `step calls recordSpan once after iteration completes`() {
+    val sut = fixture.getSut("SELECT * FROM users")
+    whenever(fixture.mockStatement.step()).thenReturn(true, true, false)
+    sut.step()
+    sut.step()
+    verifyNeverCalledRecordSpan()
+    sut.step()
+    verify(fixture.mockSpans)
+      .recordSpan(
+        eq("SELECT * FROM users"),
+        eq(fixture.startDate),
+        any(),
+        eq(SpanStatus.OK),
+        anyOrNull(),
+      )
+  }
+
+  @Test
+  fun `step that throws an exception calls recordSpan with INTERNAL_ERROR and exception`() {
+    val sut = fixture.getSut("BAD SQL")
+    val exception = RuntimeException("db error")
+    whenever(fixture.mockStatement.step()).thenThrow(exception)
+
+    assertFailsWith<RuntimeException> { sut.step() }
+
+    verify(fixture.mockSpans)
+      .recordSpan(
+        eq("BAD SQL"),
+        eq(fixture.startDate),
+        any(),
+        eq(SpanStatus.INTERNAL_ERROR),
+        eq(exception),
+      )
+  }
+
+  @Test
+  fun `step after exception calls recordSpan once new iteration cycle completes`() {
+    val sut = fixture.getSut("SELECT 1")
+    whenever(fixture.mockStatement.step())
+      .thenThrow(RuntimeException("first failure"))
+      .thenReturn(false)
+
+    assertFailsWith<RuntimeException> { sut.step() }
+    verifyCalledRecordSpan(times = 1)
+
+    sut.step()
+    verifyCalledRecordSpan(times = 2)
+  }
+
+  @Test
+  fun `step after step iteration completes does not call recordSpan again`() {
+    val sut = fixture.getSut("SELECT 1")
+    whenever(fixture.mockStatement.step()).thenReturn(true, false, false)
+
+    sut.step()
+    sut.step()
+    verifyCalledRecordSpan(times = 1)
+
+    sut.step()
+
+    verifyCalledRecordSpan(times = 1)
+    verify(fixture.mockStatement, times(3)).step()
+  }
+
+  @Test
+  fun `reset calls recordSpan if step iteration is in progress`() {
+    val sut = fixture.getSut("SELECT * FROM users")
+    whenever(fixture.mockStatement.step()).thenReturn(true)
+    sut.step()
+    sut.step()
+    verifyNeverCalledRecordSpan()
+
+    sut.reset()
+
+    verifyCalledRecordSpan()
+  }
+
+  @Test
+  fun `reset does not call recordSpan if step iteration has not started`() {
+    val sut = fixture.getSut("SELECT 1")
+    sut.reset()
+    verifyNeverCalledRecordSpan()
+  }
+
+  @Test
+  fun `reset does not call recordSpan if step iteration has completed`() {
+    val sut = fixture.getSut("SELECT * FROM users")
+    whenever(fixture.mockStatement.step()).thenReturn(true, false)
+    sut.step()
+    sut.step()
+    verifyCalledRecordSpan(times = 1)
+
+    sut.reset()
+
+    verifyCalledRecordSpan(times = 1)
+  }
+
+  @Test
+  fun `step after reset calls recordSpan when new iteration cycle completes`() {
+    val sut = fixture.getSut("SELECT 1")
+    sut.step()
+    verifyCalledRecordSpan(times = 1)
+
+    sut.reset()
+    sut.step()
+
+    verifyCalledRecordSpan(times = 2)
+  }
+
+  @Test
+  fun `close calls recordSpan if step iteration is in progress`() {
+    val sut = fixture.getSut("SELECT * FROM users")
+    whenever(fixture.mockStatement.step()).thenReturn(true)
+    sut.step()
+    sut.step()
+    verifyNeverCalledRecordSpan()
+
+    sut.close()
+
+    verifyCalledRecordSpan()
+  }
+
+  @Test
+  fun `close does not call recordSpan if step iteration has not started`() {
+    val sut = fixture.getSut("SELECT 1")
+    sut.close()
+    verifyNeverCalledRecordSpan()
+  }
+
+  @Test
+  fun `close does not call recordSpan if step iteration has completed`() {
+    val sut = fixture.getSut("SELECT * FROM users")
+    whenever(fixture.mockStatement.step()).thenReturn(true, false)
+    sut.step()
+    sut.step()
+    verifyCalledRecordSpan(times = 1)
+
+    sut.close()
+
+    verifyCalledRecordSpan(times = 1)
+  }
+
+  @Test
+  fun `step after close does not call recordSpan`() {
+    val sut = fixture.getSut("SELECT 1")
+    sut.step()
+    verifyCalledRecordSpan(times = 1)
+
+    sut.close()
+    sut.step()
+
+    verifyCalledRecordSpan(times = 1)
+  }
+
+  @Test
+  fun `reset after close does not call recordSpan`() {
+    val sut = fixture.getSut("SELECT 1")
+    whenever(fixture.mockStatement.step()).thenReturn(true)
+    sut.step()
+    sut.close()
+    verifyCalledRecordSpan(times = 1)
+
+    sut.reset()
+
+    verifyCalledRecordSpan(times = 1)
+  }
+
+  @Test
+  fun `recorded duration captures step time but excludes time between steps`() {
+    val sut = fixture.getSut("SELECT * FROM users")
+    whenever(fixture.mockStatement.step())
+      .thenAnswer {
+        fixture.fakeClock.addAndGet(10)
+        true
+      }
+      .thenAnswer {
+        fixture.fakeClock.addAndGet(20)
+        true
+      }
+      .thenAnswer {
+        fixture.fakeClock.addAndGet(30)
+        false
+      }
+
+    sut.step()
+    // Simulate work done between steps.
+    fixture.fakeClock.addAndGet(1_000_000)
+    sut.step()
+    fixture.fakeClock.addAndGet(2_000_000)
+    sut.step()
+
+    val durationCaptor = argumentCaptor<Long>()
+    verify(fixture.mockSpans).recordSpan(any(), any(), durationCaptor.capture(), any(), anyOrNull())
+    // Each step contributes its internal time (10 + 20 + 30) plus one unit from
+    // fakeClock::getAndIncrement between before/after reads, so total is 63.
+    assertEquals(63L, durationCaptor.firstValue)
+  }
+
+  @Test
+  fun `all calls are propagated to the delegate`() {
+    val sut = fixture.getSut("SELECT 1")
+
+    sut.bindBlob(0, byteArrayOf())
+    verify(fixture.mockStatement).bindBlob(0, byteArrayOf())
+
+    sut.bindDouble(0, 1.0)
+    verify(fixture.mockStatement).bindDouble(0, 1.0)
+
+    sut.bindLong(0, 1L)
+    verify(fixture.mockStatement).bindLong(0, 1L)
+
+    sut.bindText(0, "text")
+    verify(fixture.mockStatement).bindText(0, "text")
+
+    sut.bindNull(0)
+    verify(fixture.mockStatement).bindNull(0)
+
+    sut.getDouble(0)
+    verify(fixture.mockStatement).getDouble(0)
+
+    sut.getLong(0)
+    verify(fixture.mockStatement).getLong(0)
+
+    sut.getText(0)
+    verify(fixture.mockStatement).getText(0)
+
+    sut.isNull(0)
+    verify(fixture.mockStatement).isNull(0)
+
+    sut.getColumnCount()
+    verify(fixture.mockStatement).getColumnCount()
+
+    sut.getColumnName(0)
+    verify(fixture.mockStatement).getColumnName(0)
+
+    sut.step()
+    verify(fixture.mockStatement).step()
+
+    sut.reset()
+    verify(fixture.mockStatement).reset()
+
+    sut.clearBindings()
+    verify(fixture.mockStatement).clearBindings()
+
+    sut.close()
+    verify(fixture.mockStatement).close()
+  }
+
+  private fun verifyNeverCalledRecordSpan() {
+    verifyCalledRecordSpan(times = 0)
+  }
+
+  private fun verifyCalledRecordSpan(times: Int = 1) {
+    verify(fixture.mockSpans, times(times)).recordSpan(any(), any(), any(), any(), anyOrNull())
+  }
+}

From 773a0df13db7654c534b8775902021af234fa3d5 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 16 Jun 2026 09:31:06 +0200
Subject: [PATCH 203/391] ci: Remove Codecov and code coverage tooling
 (JAVA-560) (#5547)

* ci: Remove Codecov and code coverage tooling (JAVA-560)

Remove the Codecov service integration (codecov.yml, the README badge, and the upload steps across all CI workflows) along with the JaCoCo and Kover coverage tooling that only existed to feed it: the plugins, report and verification tasks across all modules, the version catalog entries, the Config.kt coverage threshold, and the createCoverageReports Makefile target.

No SDK code or public API is affected.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(sentry): Restore java.lang open after jacoco removal (JAVA-560)

SentryTest reflectively rewrites a class's name to fake the Android environment, which requires --add-opens java.base/java.lang=ALL-UNNAMED. The jacoco test agent was implicitly providing this open; now that jacoco is removed, declare it explicitly so the sentry unit tests keep passing.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .github/workflows/agp-matrix.yml              |  7 ----
 .github/workflows/build.yml                   |  9 +---
 .github/workflows/integration-tests-ui.yml    |  7 ----
 .github/workflows/spring-boot-2-matrix.yml    |  7 ----
 .github/workflows/spring-boot-3-matrix.yml    |  7 ----
 .github/workflows/spring-boot-4-matrix.yml    |  7 ----
 AGENTS.md                                     |  4 --
 Makefile                                      | 13 ++----
 README.md                                     |  1 -
 build.gradle.kts                              | 42 -------------------
 buildSrc/src/main/java/Config.kt              |  7 ----
 codecov.yml                                   | 23 ----------
 gradle/libs.versions.toml                     |  3 --
 sentry-android-core/build.gradle.kts          |  2 -
 sentry-android-fragment/build.gradle.kts      |  2 -
 sentry-android-navigation/build.gradle.kts    |  2 -
 sentry-android-ndk/build.gradle.kts           |  2 -
 sentry-android-replay/build.gradle.kts        |  2 -
 sentry-android-sqlite/build.gradle.kts        |  2 -
 sentry-android-timber/build.gradle.kts        |  2 -
 sentry-apache-http-client-5/build.gradle.kts  | 20 ---------
 sentry-apollo-3/build.gradle.kts              | 21 +---------
 sentry-apollo-4/build.gradle.kts              | 21 +---------
 sentry-apollo/build.gradle.kts                | 21 +---------
 sentry-async-profiler/build.gradle.kts        | 20 ---------
 sentry-compose/build.gradle.kts               |  1 -
 sentry-graphql-22/build.gradle.kts            | 20 ---------
 sentry-graphql-core/build.gradle.kts          | 20 ---------
 sentry-graphql/build.gradle.kts               | 20 ---------
 sentry-jcache/build.gradle.kts                | 20 ---------
 sentry-jdbc/build.gradle.kts                  | 20 ---------
 sentry-jul/build.gradle.kts                   | 17 --------
 sentry-kafka/build.gradle.kts                 | 20 ---------
 sentry-kotlin-extensions/build.gradle.kts     | 21 +---------
 sentry-ktor-client/build.gradle.kts           | 21 +---------
 sentry-launchdarkly-android/build.gradle.kts  |  2 -
 sentry-launchdarkly-server/build.gradle.kts   | 20 ---------
 sentry-log4j2/build.gradle.kts                | 20 ---------
 sentry-logback/build.gradle.kts               | 20 ---------
 sentry-okhttp/build.gradle.kts                | 21 +---------
 sentry-openfeature/build.gradle.kts           | 20 ---------
 sentry-openfeign/build.gradle.kts             | 20 ---------
 .../build.gradle.kts                          | 20 ---------
 .../build.gradle.kts                          | 20 ---------
 .../build.gradle.kts                          | 20 ---------
 .../build.gradle.kts                          | 20 ---------
 sentry-quartz/build.gradle.kts                | 20 ---------
 sentry-reactor/build.gradle.kts               | 20 ---------
 sentry-servlet-jakarta/build.gradle.kts       | 20 ---------
 sentry-servlet/build.gradle.kts               | 20 ---------
 sentry-spotlight/build.gradle.kts             | 21 +---------
 sentry-spring-7/build.gradle.kts              | 20 ---------
 sentry-spring-boot-4-starter/build.gradle.kts | 20 ---------
 sentry-spring-boot-4/build.gradle.kts         | 20 ---------
 sentry-spring-boot-jakarta/build.gradle.kts   | 20 ---------
 .../build.gradle.kts                          | 20 ---------
 sentry-spring-boot-starter/build.gradle.kts   | 20 ---------
 sentry-spring-boot/build.gradle.kts           | 20 ---------
 sentry-spring-jakarta/build.gradle.kts        | 20 ---------
 sentry-spring/build.gradle.kts                | 20 ---------
 sentry-system-test-support/build.gradle.kts   |  1 -
 sentry-test-support/build.gradle.kts          |  1 -
 sentry/build.gradle.kts                       | 28 ++++---------
 63 files changed, 20 insertions(+), 928 deletions(-)
 delete mode 100644 codecov.yml

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index aebcbf87d5e..cc9c153f252 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -112,10 +112,3 @@ jobs:
           reporter: java-junit
           output-to: step-summary
           fail-on-error: false
-
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/test-results-action@0fa95f0e1eeaafde2c782583b36b28ad0d8c77d3
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          file: build/outputs/androidTest-results/**/*.xml
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index bb1f45dd60d..9a8a7e6138d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -42,7 +42,7 @@ jobs:
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
-      - name: Run Tests with coverage and Lint
+      - name: Run Tests and Lint
         run: make preMerge
 
       - name: Install Sentry CLI
@@ -57,13 +57,6 @@ jobs:
           SENTRY_ORG: sentry-sdks
           SENTRY_PROJECT: sentry-android
 
-      - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # pin@v4
-        with:
-          name: sentry-java
-          fail_ci_if_error: false
-          token: ${{ secrets.CODECOV_TOKEN }}
-
       - name: Upload test results
         if: always()
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 4af564cd2c3..102951a6d40 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -94,10 +94,3 @@ jobs:
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
           SENTRY_ORG: sentry-sdks
           SENTRY_PROJECT: sentry-android
-
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/test-results-action@0fa95f0e1eeaafde2c782583b36b28ad0d8c77d3
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          file: ./artifacts/*.xml
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 32eeef2442d..b9eb217d578 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -150,10 +150,3 @@ jobs:
           reporter: java-junit
           output-to: step-summary
           fail-on-error: false
-
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/test-results-action@0fa95f0e1eeaafde2c782583b36b28ad0d8c77d3
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          file: '**/build/test-results/**/*.xml'
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 8614e2ca69d..82f379c141c 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -146,10 +146,3 @@ jobs:
           reporter: java-junit
           output-to: step-summary
           fail-on-error: false
-
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/test-results-action@0fa95f0e1eeaafde2c782583b36b28ad0d8c77d3
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          file: '**/build/test-results/**/*.xml'
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index e82b120ec24..d2ec6c096bf 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -146,10 +146,3 @@ jobs:
           reporter: java-junit
           output-to: step-summary
           fail-on-error: false
-
-      - name: Upload test results to Codecov
-        if: ${{ !cancelled() }}
-        uses: codecov/test-results-action@0fa95f0e1eeaafde2c782583b36b28ad0d8c77d3
-        with:
-          token: ${{ secrets.CODECOV_TOKEN }}
-          file: '**/build/test-results/**/*.xml'
diff --git a/AGENTS.md b/AGENTS.md
index 8d0cccabbc7..a05d9386607 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -37,9 +37,6 @@ The project uses **Gradle** with Kotlin DSL. Key build files:
 # Build entire project
 ./gradlew build
 
-# Create coverage reports
-./gradlew jacocoTestReport koverXmlReportRelease
-
 # Generate documentation
 ./gradlew aggregateJavadocs
 ```
@@ -149,7 +146,6 @@ The repository is organized into multiple modules:
 - Write comprehensive unit tests for new features
 - Android modules require both unit tests and instrumented tests where applicable
 - System tests validate end-to-end functionality with sample applications
-- Coverage reports are generated for both JaCoCo (Java/Android) and Kover (KMP modules)
 
 ### Contributing Guidelines
 1. Follow existing code style and language
diff --git a/Makefile b/Makefile
index c9eca8b8b7e..3967ff856ad 100644
--- a/Makefile
+++ b/Makefile
@@ -1,9 +1,9 @@
-.PHONY: all clean compile javadocs dryRelease update checkFormat api assembleBenchmarkTestRelease assembleUiTestRelease assembleUiTestCriticalRelease createCoverageReports runUiTestCritical setupPython systemTest systemTestInteractive check preMerge publish
+.PHONY: all clean compile javadocs dryRelease update checkFormat api assembleBenchmarkTestRelease assembleUiTestRelease assembleUiTestCriticalRelease runUiTestCritical setupPython systemTest systemTestInteractive check preMerge publish
 
-all: stop clean javadocs compile createCoverageReports
+all: stop clean javadocs compile
 assembleBenchmarks: assembleBenchmarkTestRelease
 assembleUiTests: assembleUiTestRelease
-preMerge: check createCoverageReports
+preMerge: check
 publish: clean dryRelease
 
 # deep clean
@@ -51,13 +51,6 @@ assembleUiTestCriticalRelease:
 runUiTestCritical:
 	./scripts/test-ui-critical.sh
 
-# Create coverage reports
-#  - Jacoco for Java & Android modules
-#  - Kover for KMP modules e.g sentry-compose
-createCoverageReports:
-	./gradlew jacocoTestReport
-	./gradlew koverXmlReportRelease
-
 # Create the Python virtual environment for system tests, and install the necessary dependencies
 setupPython:
 	@test -d .venv || python3 -m venv .venv
diff --git a/README.md b/README.md
index 9aaf7aca4d8..0aab8a4e75d 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,6 @@ _Bad software is everywhere, and we're tired of it. Sentry is on a mission to he
 Sentry SDK for Java and Android
 ===========
 [![GH Workflow](https://img.shields.io/github/actions/workflow/status/getsentry/sentry-java/build.yml?branch=main)](https://github.com/getsentry/sentry-java/actions)
-[![codecov](https://codecov.io/gh/getsentry/sentry-java/branch/main/graph/badge.svg)](https://codecov.io/gh/getsentry/sentry-java)
 [![X Follow](https://img.shields.io/twitter/follow/sentry?label=sentry&style=social)](https://x.com/intent/follow?screen_name=sentry)
 [![Discord Chat](https://img.shields.io/discord/621778831602221064?logo=discord&logoColor=ffffff&color=7389D8)](https://discord.gg/PXa5Apfe7K)
 
diff --git a/build.gradle.kts b/build.gradle.kts
index d5b5dfc5d05..93c82cd8c9a 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -3,19 +3,15 @@ import com.vanniktech.maven.publish.JavadocJar
 import com.vanniktech.maven.publish.MavenPublishBaseExtension
 import groovy.util.Node
 import io.gitlab.arturbosch.detekt.extensions.DetektExtension
-import kotlinx.kover.gradle.plugin.dsl.KoverReportExtension
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
 import org.gradle.api.tasks.testing.logging.TestLogEvent
 
 plugins {
     `java-library`
     alias(libs.plugins.spotless) apply false
-    jacoco
     alias(libs.plugins.detekt)
     `maven-publish`
     alias(libs.plugins.binary.compatibility.validator)
-    alias(libs.plugins.jacoco.android) apply false
-    alias(libs.plugins.kover) apply false
     alias(libs.plugins.vanniktech.maven.publish) apply false
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.multiplatform) apply false
@@ -121,44 +117,6 @@ allprojects {
 subprojects {
     apply { plugin("io.sentry.spotless") }
 
-    val jacocoAndroidModules = listOf(
-        "sentry-android-core",
-        "sentry-android-fragment",
-        "sentry-android-navigation",
-        "sentry-android-ndk",
-        "sentry-android-sqlite",
-        "sentry-android-replay",
-        "sentry-android-timber"
-    )
-    if (jacocoAndroidModules.contains(name)) {
-        afterEvaluate {
-            jacoco {
-                toolVersion = "0.8.10"
-            }
-
-            tasks.withType<Test>().configureEach {
-                configure<JacocoTaskExtension> {
-                    isIncludeNoLocationClasses = true
-                    excludes = listOf("jdk.internal.*")
-                }
-            }
-        }
-    }
-
-    val koverKmpModules = listOf("sentry-compose")
-    if (koverKmpModules.contains(name)) {
-        afterEvaluate {
-            configure<KoverReportExtension> {
-                androidReports("release") {
-                    xml {
-                        // Change the report file name so the Codecov Github action can find it
-                        setReportFile(project.layout.buildDirectory.file("reports/kover/report.xml").get().asFile)
-                    }
-                }
-            }
-        }
-    }
-
     plugins.withId(Config.QualityPlugins.detektPlugin) {
         configure<DetektExtension> {
             buildUponDefaultConfig = true
diff --git a/buildSrc/src/main/java/Config.kt b/buildSrc/src/main/java/Config.kt
index 3410d9601d3..f0e2e9baf86 100644
--- a/buildSrc/src/main/java/Config.kt
+++ b/buildSrc/src/main/java/Config.kt
@@ -1,6 +1,4 @@
 
-import java.math.BigDecimal
-
 object Config {
     val AGP = System.getenv("VERSION_AGP") ?: "8.13.1"
     val kotlinStdLib = "stdlib-jdk8"
@@ -37,11 +35,6 @@ object Config {
     }
 
     object QualityPlugins {
-        object Jacoco {
-            // TODO [POTEL] add tests and restore
-            val minimumCoverage = BigDecimal.valueOf(0.1)
-        }
-
         // this can be removed when we upgrade to Gradle 8, which allows us to use a getter for the plugin ID
         val detektPlugin = "io.gitlab.arturbosch.detekt"
     }
diff --git a/codecov.yml b/codecov.yml
deleted file mode 100644
index 3a53b1f7b3f..00000000000
--- a/codecov.yml
+++ /dev/null
@@ -1,23 +0,0 @@
-comment: no
-codecov:
-  require_ci_to_pass: no
-  max_report_age: off
-
-coverage:
-  status:
-    project:
-      default:
-        target: 78%
-        threshold: 4%
-    patch: off
-  range: 78...100
-  precision: 3
-  round: down
-
-ignore:
-  - "**/src/test/*"
-  - "sentry-android-integration-tests/*"
-  - "sentry-system-test-support/*"
-  - "sentry-test-support/*"
-  - "sentry-samples/*"
-  - "sentry-async-profiler/src/main/java/io/sentry/asyncprofiler/vendor/asyncprofiler/**"
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 1ebcb8e0e38..a305275a118 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -9,7 +9,6 @@ composeCompiler = "1.5.14"
 coroutines = "1.6.1"
 espresso = "3.7.0"
 feign = "11.6"
-jacoco = "0.8.7"
 jackson = "2.18.3"
 jetbrainsCompose = "1.6.11"
 kotlin = "2.2.0"
@@ -59,8 +58,6 @@ errorprone = { id = "net.ltgt.errorprone", version = "3.0.1" }
 gradle-versions = { id = "com.github.ben-manes.versions", version = "0.42.0" }
 spotless = { id = "com.diffplug.spotless", version.ref = "spotless" }
 detekt = { id = "io.gitlab.arturbosch.detekt", version = "1.23.8" }
-jacoco-android = { id = "com.mxalbert.gradle.jacoco-android", version = "0.2.0" }
-kover = { id = "org.jetbrains.kotlinx.kover", version = "0.7.3" }
 vanniktech-maven-publish = { id = "com.vanniktech.maven.publish", version = "0.30.0" }
 springboot3 = { id = "org.springframework.boot", version.ref = "springboot3" }
 springboot4 = { id = "org.springframework.boot", version.ref = "springboot4" }
diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index abcca4f8833..f7440b19494 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -5,8 +5,6 @@ plugins {
   id("com.android.library")
   alias(libs.plugins.kotlin.android)
   alias(libs.plugins.kotlin.compose)
-  jacoco
-  alias(libs.plugins.jacoco.android)
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
 }
diff --git a/sentry-android-fragment/build.gradle.kts b/sentry-android-fragment/build.gradle.kts
index 7a4178b0652..1bd182d618c 100644
--- a/sentry-android-fragment/build.gradle.kts
+++ b/sentry-android-fragment/build.gradle.kts
@@ -3,8 +3,6 @@ import io.gitlab.arturbosch.detekt.Detekt
 plugins {
   id("com.android.library")
   alias(libs.plugins.kotlin.android)
-  jacoco
-  alias(libs.plugins.jacoco.android)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.detekt)
 }
diff --git a/sentry-android-navigation/build.gradle.kts b/sentry-android-navigation/build.gradle.kts
index 7f5d1017ec3..eaa204b3860 100644
--- a/sentry-android-navigation/build.gradle.kts
+++ b/sentry-android-navigation/build.gradle.kts
@@ -3,8 +3,6 @@ import io.gitlab.arturbosch.detekt.Detekt
 plugins {
   id("com.android.library")
   alias(libs.plugins.kotlin.android)
-  jacoco
-  alias(libs.plugins.jacoco.android)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.detekt)
 }
diff --git a/sentry-android-ndk/build.gradle.kts b/sentry-android-ndk/build.gradle.kts
index 413fd3a7b77..c2d0a33d823 100644
--- a/sentry-android-ndk/build.gradle.kts
+++ b/sentry-android-ndk/build.gradle.kts
@@ -3,8 +3,6 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion
 plugins {
   id("com.android.library")
   alias(libs.plugins.kotlin.android)
-  jacoco
-  alias(libs.plugins.jacoco.android)
   alias(libs.plugins.gradle.versions)
 }
 
diff --git a/sentry-android-replay/build.gradle.kts b/sentry-android-replay/build.gradle.kts
index 60d38c0ae0a..8d0f63797aa 100644
--- a/sentry-android-replay/build.gradle.kts
+++ b/sentry-android-replay/build.gradle.kts
@@ -5,8 +5,6 @@ plugins {
   id("com.android.library")
   alias(libs.plugins.kotlin.android)
   alias(libs.plugins.kotlin.compose)
-  jacoco
-  alias(libs.plugins.jacoco.android)
   alias(libs.plugins.gradle.versions)
   // TODO: enable it later
   //    alias(libs.plugins.detekt)
diff --git a/sentry-android-sqlite/build.gradle.kts b/sentry-android-sqlite/build.gradle.kts
index 07fa7ad343f..dd28252665e 100644
--- a/sentry-android-sqlite/build.gradle.kts
+++ b/sentry-android-sqlite/build.gradle.kts
@@ -3,8 +3,6 @@ import io.gitlab.arturbosch.detekt.Detekt
 plugins {
   id("com.android.library")
   alias(libs.plugins.kotlin.android)
-  jacoco
-  alias(libs.plugins.jacoco.android)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.detekt)
 }
diff --git a/sentry-android-timber/build.gradle.kts b/sentry-android-timber/build.gradle.kts
index 16083b43f1b..d8f8431bef1 100644
--- a/sentry-android-timber/build.gradle.kts
+++ b/sentry-android-timber/build.gradle.kts
@@ -3,8 +3,6 @@ import io.gitlab.arturbosch.detekt.Detekt
 plugins {
   id("com.android.library")
   alias(libs.plugins.kotlin.android)
-  jacoco
-  alias(libs.plugins.jacoco.android)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.detekt)
 }
diff --git a/sentry-apache-http-client-5/build.gradle.kts b/sentry-apache-http-client-5/build.gradle.kts
index 4c9aba6e31b..df93fbe8823 100644
--- a/sentry-apache-http-client-5/build.gradle.kts
+++ b/sentry-apache-http-client-5/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
 }
@@ -36,25 +35,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-apollo-3/build.gradle.kts b/sentry-apollo-3/build.gradle.kts
index 8819e0993d4..1eb71bc217a 100644
--- a/sentry-apollo-3/build.gradle.kts
+++ b/sentry-apollo-3/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -45,25 +44,7 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-    dependsOn(animalsnifferMain)
-  }
-}
+tasks { check { dependsOn(animalsnifferMain) } }
 
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
diff --git a/sentry-apollo-4/build.gradle.kts b/sentry-apollo-4/build.gradle.kts
index 85ea2c3b52b..144297ddb9d 100644
--- a/sentry-apollo-4/build.gradle.kts
+++ b/sentry-apollo-4/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -52,25 +51,7 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-    dependsOn(animalsnifferMain)
-  }
-}
+tasks { check { dependsOn(animalsnifferMain) } }
 
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
diff --git a/sentry-apollo/build.gradle.kts b/sentry-apollo/build.gradle.kts
index 909d52aa127..c115e6b8fe3 100644
--- a/sentry-apollo/build.gradle.kts
+++ b/sentry-apollo/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -46,25 +45,7 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-    dependsOn(animalsnifferMain)
-  }
-}
+tasks { check { dependsOn(animalsnifferMain) } }
 
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
diff --git a/sentry-async-profiler/build.gradle.kts b/sentry-async-profiler/build.gradle.kts
index 5af2f0bef45..ef000b465a1 100644
--- a/sentry-async-profiler/build.gradle.kts
+++ b/sentry-async-profiler/build.gradle.kts
@@ -4,7 +4,6 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 plugins {
   `java-library`
   kotlin("jvm")
-  jacoco
   id("io.sentry.javadoc")
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
@@ -39,25 +38,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-compose/build.gradle.kts b/sentry-compose/build.gradle.kts
index 3385d0328e2..c45a431b1b3 100644
--- a/sentry-compose/build.gradle.kts
+++ b/sentry-compose/build.gradle.kts
@@ -7,7 +7,6 @@ plugins {
   alias(libs.plugins.kotlin.multiplatform)
   alias(libs.plugins.kotlin.compose)
   id("com.android.library")
-  alias(libs.plugins.kover)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.detekt)
   alias(libs.plugins.dokka)
diff --git a/sentry-graphql-22/build.gradle.kts b/sentry-graphql-22/build.gradle.kts
index a8256ca8a27..c36ca09856d 100644
--- a/sentry-graphql-22/build.gradle.kts
+++ b/sentry-graphql-22/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -44,25 +43,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-graphql-core/build.gradle.kts b/sentry-graphql-core/build.gradle.kts
index cb8c9f49493..d625c31dea6 100644
--- a/sentry-graphql-core/build.gradle.kts
+++ b/sentry-graphql-core/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -43,25 +42,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-graphql/build.gradle.kts b/sentry-graphql/build.gradle.kts
index 46bef6e4b9d..68efbc7389e 100644
--- a/sentry-graphql/build.gradle.kts
+++ b/sentry-graphql/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -44,25 +43,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-jcache/build.gradle.kts b/sentry-jcache/build.gradle.kts
index a9393a7d905..2c476dbd007 100644
--- a/sentry-jcache/build.gradle.kts
+++ b/sentry-jcache/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -39,25 +38,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-jdbc/build.gradle.kts b/sentry-jdbc/build.gradle.kts
index 0415fd8ccff..8a7808530b1 100644
--- a/sentry-jdbc/build.gradle.kts
+++ b/sentry-jdbc/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -37,25 +36,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-jul/build.gradle.kts b/sentry-jul/build.gradle.kts
index 13bee6418d6..b59a1481d19 100644
--- a/sentry-jul/build.gradle.kts
+++ b/sentry-jul/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -36,23 +35,7 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
 tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
   test {
     // used to test io.sentry.jul.SentryHandler
     systemProperty(
diff --git a/sentry-kafka/build.gradle.kts b/sentry-kafka/build.gradle.kts
index ee3ba0d4a60..603014f9af9 100644
--- a/sentry-kafka/build.gradle.kts
+++ b/sentry-kafka/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -36,25 +35,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-kotlin-extensions/build.gradle.kts b/sentry-kotlin-extensions/build.gradle.kts
index 55aca007130..5092976de32 100644
--- a/sentry-kotlin-extensions/build.gradle.kts
+++ b/sentry-kotlin-extensions/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.detekt)
@@ -40,25 +39,7 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-    dependsOn(animalsnifferMain)
-  }
-}
+tasks { check { dependsOn(animalsnifferMain) } }
 
 tasks.withType<Detekt>().configureEach {
   // Target version of the generated JVM bytecode. It is used for type resolution.
diff --git a/sentry-ktor-client/build.gradle.kts b/sentry-ktor-client/build.gradle.kts
index 2965e81ebd3..745acaa11fb 100644
--- a/sentry-ktor-client/build.gradle.kts
+++ b/sentry-ktor-client/build.gradle.kts
@@ -4,7 +4,6 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 plugins {
   `java-library`
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   id("io.sentry.javadoc")
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
@@ -47,25 +46,7 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-    dependsOn(animalsnifferMain)
-  }
-}
+tasks { check { dependsOn(animalsnifferMain) } }
 
 buildConfig {
   useJavaOutput()
diff --git a/sentry-launchdarkly-android/build.gradle.kts b/sentry-launchdarkly-android/build.gradle.kts
index bf59c256ed1..427ec473676 100644
--- a/sentry-launchdarkly-android/build.gradle.kts
+++ b/sentry-launchdarkly-android/build.gradle.kts
@@ -1,8 +1,6 @@
 plugins {
   id("com.android.library")
   alias(libs.plugins.kotlin.android)
-  jacoco
-  alias(libs.plugins.jacoco.android)
   alias(libs.plugins.gradle.versions)
 }
 
diff --git a/sentry-launchdarkly-server/build.gradle.kts b/sentry-launchdarkly-server/build.gradle.kts
index ee273fa5a9c..207400676a0 100644
--- a/sentry-launchdarkly-server/build.gradle.kts
+++ b/sentry-launchdarkly-server/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -40,25 +39,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-log4j2/build.gradle.kts b/sentry-log4j2/build.gradle.kts
index 68ebd90b1e8..7d406076e2f 100644
--- a/sentry-log4j2/build.gradle.kts
+++ b/sentry-log4j2/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -38,25 +37,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.log4j2")
diff --git a/sentry-logback/build.gradle.kts b/sentry-logback/build.gradle.kts
index 385209e8c49..d2084e95467 100644
--- a/sentry-logback/build.gradle.kts
+++ b/sentry-logback/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -35,25 +34,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.logback")
diff --git a/sentry-okhttp/build.gradle.kts b/sentry-okhttp/build.gradle.kts
index f7178cf1dfe..ea831f174cc 100644
--- a/sentry-okhttp/build.gradle.kts
+++ b/sentry-okhttp/build.gradle.kts
@@ -4,7 +4,6 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 plugins {
   `java-library`
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   id("io.sentry.javadoc")
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
@@ -46,25 +45,7 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-    dependsOn(animalsnifferMain)
-  }
-}
+tasks { check { dependsOn(animalsnifferMain) } }
 
 buildConfig {
   useJavaOutput()
diff --git a/sentry-openfeature/build.gradle.kts b/sentry-openfeature/build.gradle.kts
index 632d16b55cf..5847f48e7b5 100644
--- a/sentry-openfeature/build.gradle.kts
+++ b/sentry-openfeature/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -40,25 +39,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-openfeign/build.gradle.kts b/sentry-openfeign/build.gradle.kts
index 40119987f72..e9e3a2b18de 100644
--- a/sentry-openfeign/build.gradle.kts
+++ b/sentry-openfeign/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -37,25 +36,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts
index b4a84300efd..ed6605f8da4 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
 }
@@ -43,25 +42,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
index 64db4096bb9..503c92c95f0 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
 }
@@ -38,25 +37,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
index 2ab3d4988d5..5b3b9d97ff4 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
 }
@@ -48,25 +47,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
index f039b3c95ef..21e75c0ed7d 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
 }
@@ -44,25 +43,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-quartz/build.gradle.kts b/sentry-quartz/build.gradle.kts
index f81254f110f..69c0e72ee07 100644
--- a/sentry-quartz/build.gradle.kts
+++ b/sentry-quartz/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -38,25 +37,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-reactor/build.gradle.kts b/sentry-reactor/build.gradle.kts
index 9e8b6e74be9..4d389b0a334 100644
--- a/sentry-reactor/build.gradle.kts
+++ b/sentry-reactor/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -46,25 +45,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.reactor")
diff --git a/sentry-servlet-jakarta/build.gradle.kts b/sentry-servlet-jakarta/build.gradle.kts
index ec079b6d65f..728e147dc9b 100644
--- a/sentry-servlet-jakarta/build.gradle.kts
+++ b/sentry-servlet-jakarta/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -38,25 +37,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-servlet/build.gradle.kts b/sentry-servlet/build.gradle.kts
index ceaa160695a..142a1cd2f20 100644
--- a/sentry-servlet/build.gradle.kts
+++ b/sentry-servlet/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -39,25 +38,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-spotlight/build.gradle.kts b/sentry-spotlight/build.gradle.kts
index dbab6237b12..b034c8267db 100644
--- a/sentry-spotlight/build.gradle.kts
+++ b/sentry-spotlight/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.animalsniffer)
@@ -38,25 +37,7 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-    dependsOn(animalsnifferMain)
-  }
-}
+tasks { check { dependsOn(animalsnifferMain) } }
 
 buildConfig {
   useJavaOutput()
diff --git a/sentry-spring-7/build.gradle.kts b/sentry-spring-7/build.gradle.kts
index ae8269e7825..ec90aedcbeb 100644
--- a/sentry-spring-7/build.gradle.kts
+++ b/sentry-spring-7/build.gradle.kts
@@ -6,7 +6,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -85,25 +84,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring7")
diff --git a/sentry-spring-boot-4-starter/build.gradle.kts b/sentry-spring-boot-4-starter/build.gradle.kts
index 2c8eab0ba66..c0f655e965f 100644
--- a/sentry-spring-boot-4-starter/build.gradle.kts
+++ b/sentry-spring-boot-4-starter/build.gradle.kts
@@ -6,7 +6,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.springboot4) apply false
@@ -41,25 +40,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-spring-boot-4/build.gradle.kts b/sentry-spring-boot-4/build.gradle.kts
index 3b0b3be8630..43e105ad8db 100644
--- a/sentry-spring-boot-4/build.gradle.kts
+++ b/sentry-spring-boot-4/build.gradle.kts
@@ -5,7 +5,6 @@ import org.springframework.boot.gradle.plugin.SpringBootPlugin
 plugins {
   `java-library`
   id("io.sentry.javadoc")
-  jacoco
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
   alias(libs.plugins.errorprone)
@@ -111,25 +110,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring.boot4")
diff --git a/sentry-spring-boot-jakarta/build.gradle.kts b/sentry-spring-boot-jakarta/build.gradle.kts
index 36b7dad3cc6..edd2d605916 100644
--- a/sentry-spring-boot-jakarta/build.gradle.kts
+++ b/sentry-spring-boot-jakarta/build.gradle.kts
@@ -6,7 +6,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -103,25 +102,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring.boot.jakarta")
diff --git a/sentry-spring-boot-starter-jakarta/build.gradle.kts b/sentry-spring-boot-starter-jakarta/build.gradle.kts
index 60ac812b013..d7d10b73b8c 100644
--- a/sentry-spring-boot-starter-jakarta/build.gradle.kts
+++ b/sentry-spring-boot-starter-jakarta/build.gradle.kts
@@ -6,7 +6,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.springboot3) apply false
@@ -41,25 +40,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-spring-boot-starter/build.gradle.kts b/sentry-spring-boot-starter/build.gradle.kts
index 6b5bcdf5752..3ef4ac59379 100644
--- a/sentry-spring-boot-starter/build.gradle.kts
+++ b/sentry-spring-boot-starter/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
 }
@@ -33,25 +32,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-spring-boot/build.gradle.kts b/sentry-spring-boot/build.gradle.kts
index e54112ae54c..3ed6199fbc5 100644
--- a/sentry-spring-boot/build.gradle.kts
+++ b/sentry-spring-boot/build.gradle.kts
@@ -6,7 +6,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -85,25 +84,6 @@ dependencies {
   testImplementation(projects.sentryAsyncProfiler)
 }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring.boot")
diff --git a/sentry-spring-jakarta/build.gradle.kts b/sentry-spring-jakarta/build.gradle.kts
index cbf2e5346b5..b4a61129df7 100644
--- a/sentry-spring-jakarta/build.gradle.kts
+++ b/sentry-spring-jakarta/build.gradle.kts
@@ -6,7 +6,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -80,25 +79,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring.jakarta")
diff --git a/sentry-spring/build.gradle.kts b/sentry-spring/build.gradle.kts
index 64380f7e7f4..fced2220f02 100644
--- a/sentry-spring/build.gradle.kts
+++ b/sentry-spring/build.gradle.kts
@@ -6,7 +6,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -64,25 +63,6 @@ dependencies {
   testImplementation(libs.springboot.starter.webflux)
 }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
-tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-  }
-}
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring")
diff --git a/sentry-system-test-support/build.gradle.kts b/sentry-system-test-support/build.gradle.kts
index b8e4a283c87..4d4c7d5bb6e 100644
--- a/sentry-system-test-support/build.gradle.kts
+++ b/sentry-system-test-support/build.gradle.kts
@@ -2,7 +2,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   id("com.apollographql.apollo") version "4.1.1"
diff --git a/sentry-test-support/build.gradle.kts b/sentry-test-support/build.gradle.kts
index 29b2083a0a9..f108915d463 100644
--- a/sentry-test-support/build.gradle.kts
+++ b/sentry-test-support/build.gradle.kts
@@ -2,7 +2,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
 }
diff --git a/sentry/build.gradle.kts b/sentry/build.gradle.kts
index 4c237803a51..a2ecd281296 100644
--- a/sentry/build.gradle.kts
+++ b/sentry/build.gradle.kts
@@ -5,7 +5,6 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
-  jacoco
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
@@ -40,15 +39,6 @@ dependencies {
 
 configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
 
-jacoco { toolVersion = libs.versions.jacoco.get() }
-
-tasks.jacocoTestReport {
-  reports {
-    xml.required.set(true)
-    html.required.set(false)
-  }
-}
-
 animalsniffer {
   ignore =
     listOf(
@@ -63,16 +53,16 @@ tasks.animalsnifferMain {
 }
 
 tasks {
-  jacocoTestCoverageVerification {
-    violationRules { rule { limit { minimum = Config.QualityPlugins.Jacoco.minimumCoverage } } }
-  }
-  check {
-    dependsOn(jacocoTestCoverageVerification)
-    dependsOn(jacocoTestReport)
-    dependsOn(animalsnifferMain)
-  }
+  check { dependsOn(animalsnifferMain) }
   test {
-    jvmArgs("--add-opens", "java.base/java.util.concurrent=ALL-UNNAMED")
+    // java.lang open is needed by tests that reflectively rewrite Class names; it was previously
+    // provided implicitly by the jacoco test agent, which has been removed.
+    jvmArgs(
+      "--add-opens",
+      "java.base/java.util.concurrent=ALL-UNNAMED",
+      "--add-opens",
+      "java.base/java.lang=ALL-UNNAMED",
+    )
     environment["SENTRY_TEST_PROPERTY"] = "\"some-value\""
     environment["SENTRY_TEST_MAP_KEY1"] = "\"value1\""
     environment["SENTRY_TEST_MAP_KEY2"] = "value2"

From f36e6e37ec1517fa6e3c06ab79abc6775e2ef1bf Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 16 Jun 2026 13:40:05 +0200
Subject: [PATCH 204/391] fix(android): Stop duplicating attachments on native
 events (JAVA-559) (#5548)

* fix(android): Stop duplicating attachments on native events (JAVA-559)

Scope attachments are synced to the native SDK, so native events already
carry them as envelope items in the outbox. When re-ingesting those
cached envelopes, SentryClient re-applied the scope attachments on top,
sending each attachment twice. Skip re-applying scope attachments for
cached envelopes.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../src/main/java/io/sentry/SentryClient.java |  4 +++-
 .../test/java/io/sentry/SentryClientTest.kt   | 19 +++++++++++++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 648533ec18f..93cd3765da8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,7 @@
 
 ### Fixes
 
+- Fix attachments being duplicated on native events that carry scope attachments ([#5548](https://github.com/getsentry/sentry-java/pull/5548))
 - Fix performance collector scheduling many tasks in a row ([#5524](https://github.com/getsentry/sentry-java/pull/5524))
 
 ## 8.43.2
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index 5ac81c44936..78225f05d19 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -112,7 +112,9 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
       hint = new Hint();
     }
 
-    if (shouldApplyScopeData(event, hint)) {
+    // Cached envelopes (e.g. native crashes from the outbox) already carry their attachments as
+    // envelope items. Re-applying scope attachments here would duplicate them.
+    if (shouldApplyScopeData(event, hint) && !HintUtils.hasType(hint, Cached.class)) {
       addScopeAttachmentsToHint(scope, hint);
     }
 
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index d5b2f0f82a0..ab6fd2075a3 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -870,6 +870,25 @@ class SentryClientTest {
     assertEquals(scope.level, event.level)
   }
 
+  @Test
+  fun `when hint is Cached, scope attachments are not added to avoid duplication`() {
+    val sut = fixture.getSut()
+
+    val event = createEvent()
+    val scope = createScopeWithAttachments()
+
+    val hints = HintUtils.createWithTypeCheckHint(CustomCachedApplyScopeDataHint())
+    sut.captureEvent(event, scope, hints)
+
+    verify(fixture.transport)
+      .send(
+        check { actual ->
+          assertEquals(0, actual.items.count { it.header.type == SentryItemType.Attachment })
+        },
+        anyOrNull(),
+      )
+  }
+
   @Test
   fun `when transport factory is NoOp, it should initialize it`() {
     fixture.sentryOptions.setTransportFactory(NoOpTransportFactory.getInstance())

From 6dff1c9970ad612ac431980c08abb138218465e0 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 16 Jun 2026 11:52:26 +0000
Subject: [PATCH 205/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.15.0 (#5528)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 3 +++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 93cd3765da8..71c8d990122 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,9 @@
 ### Dependencies
 
 - Upgrade to asyncProfiler 4.4 ([#5418](https://github.com/getsentry/sentry-java/pull/5418))
+- Bump Native SDK from v0.14.2 to v0.15.0 ([#5528](https://github.com/getsentry/sentry-java/pull/5528))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0150)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.14.2...0.15.0)
 
 ### Fixes
 
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index a305275a118..c16a87ad9b6 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -150,7 +150,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.14.2" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.0" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From e52b4e44a1eb195adcd0fbe2761d33e708ac5d49 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 17 Jun 2026 09:49:21 +0200
Subject: [PATCH 206/391] chore(deps): bump actions/setup-java in the
 github-actions group (#5554)

Bumps the github-actions group with 1 update: [actions/setup-java](https://github.com/actions/setup-java).


Updates `actions/setup-java` from 5.2.0 to 5.3.0
- [Release notes](https://github.com/actions/setup-java/releases)
- [Commits](https://github.com/actions/setup-java/compare/be666c2fcd27ec809703dec50e508c2fdc7f6654...ad2b38190b15e4d6bdf0c97fb4fca8412226d287)

---
updated-dependencies:
- dependency-name: actions/setup-java
  dependency-version: 5.3.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/codeql-analysis.yml               | 2 +-
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 15 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index cc9c153f252..40f8509fee4 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -33,7 +33,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 9a8a7e6138d..375e94e7499 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -25,7 +25,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 6aa197d6625..e24b7c96c14 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -25,7 +25,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index 01ee3db1584..e5e4530933b 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -14,7 +14,7 @@ jobs:
         uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
 
       - name: Set up Java
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index 28cb78df4e3..ec427af3564 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -13,7 +13,7 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index af0b44ddadd..2e82024077a 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -14,7 +14,7 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 65cfcf242fc..4d323f0394a 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -32,7 +32,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -82,7 +82,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index 19598699165..e2fa42ddc16 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -23,7 +23,7 @@ jobs:
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
 
       - name: Setup Java Version
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: "temurin"
           java-version: "17"
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 8973148cadd..18809c060e1 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -30,7 +30,7 @@ jobs:
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
 
       - name: Set up Java 17
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 102951a6d40..f7b95a26d12 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -27,7 +27,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 16cfe4531a0..9fecaf32b5e 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -20,7 +20,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index b9eb217d578..7628a0bbba0 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 82f379c141c..40670eaf258 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index d2ec6c096bf..128051ed03e 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index b1884cd4a7a..62a1b7665c0 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -112,7 +112,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
         with:
           distribution: 'temurin'
           java-version: '17'

From ba010111864967003758a5e4d750dfe04f995c18 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 17 Jun 2026 13:17:06 +0200
Subject: [PATCH 207/391] perf: Avoid boxing in doubleToBigDecimal timestamp
 serialization (#5551)

* perf: Avoid boxing in doubleToBigDecimal timestamp serialization

Change DateUtils.doubleToBigDecimal to take a primitive double instead of a
boxed Double, and route the four duplicated private copies (ProfileChunk,
ProfileMeasurementValue, SentrySample, SentrySpan) through it. Callers that
hold a primitive double timestamp no longer autobox on every serialization,
and the duplicated helpers are consolidated into one. Behavior is unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                              | 2 +-
 sentry/api/sentry.api                                     | 2 +-
 sentry/src/main/java/io/sentry/DateUtils.java             | 2 +-
 sentry/src/main/java/io/sentry/ProfileChunk.java          | 8 ++------
 .../profilemeasurements/ProfileMeasurementValue.java      | 8 ++------
 sentry/src/main/java/io/sentry/protocol/SentrySpan.java   | 8 ++------
 .../java/io/sentry/protocol/profiling/SentrySample.java   | 8 ++------
 7 files changed, 11 insertions(+), 27 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 71c8d990122..5dbcde58f10 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,7 +12,7 @@
 
 ### Improvements
 
-- Reduce boxing to improve performance ([#5523](https://github.com/getsentry/sentry-java/pull/5523), [#5527](https://github.com/getsentry/sentry-java/pull/5527))
+- Reduce boxing to improve performance ([#5523](https://github.com/getsentry/sentry-java/pull/5523), [#5527](https://github.com/getsentry/sentry-java/pull/5527), [#5551](https://github.com/getsentry/sentry-java/pull/5551))
 
 ### Dependencies
 
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 4757be4894a..22f9366f738 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -384,7 +384,7 @@ public final class io/sentry/DataCategory : java/lang/Enum {
 public final class io/sentry/DateUtils {
 	public static fun dateToNanos (Ljava/util/Date;)J
 	public static fun dateToSeconds (Ljava/util/Date;)D
-	public static fun doubleToBigDecimal (Ljava/lang/Double;)Ljava/math/BigDecimal;
+	public static fun doubleToBigDecimal (D)Ljava/math/BigDecimal;
 	public static fun getCurrentDateTime ()Ljava/util/Date;
 	public static fun getDateTime (J)Ljava/util/Date;
 	public static fun getDateTime (Ljava/lang/String;)Ljava/util/Date;
diff --git a/sentry/src/main/java/io/sentry/DateUtils.java b/sentry/src/main/java/io/sentry/DateUtils.java
index 5e55512ae70..b86bddeaad8 100644
--- a/sentry/src/main/java/io/sentry/DateUtils.java
+++ b/sentry/src/main/java/io/sentry/DateUtils.java
@@ -166,7 +166,7 @@ public static long secondsToNanos(final @NotNull long seconds) {
     return seconds * (1000L * 1000L * 1000L);
   }
 
-  public static @NotNull BigDecimal doubleToBigDecimal(final @NotNull Double value) {
+  public static @NotNull BigDecimal doubleToBigDecimal(final double value) {
     return BigDecimal.valueOf(value).setScale(6, RoundingMode.DOWN);
   }
 }
diff --git a/sentry/src/main/java/io/sentry/ProfileChunk.java b/sentry/src/main/java/io/sentry/ProfileChunk.java
index a6145ca8e9a..1d159030c1d 100644
--- a/sentry/src/main/java/io/sentry/ProfileChunk.java
+++ b/sentry/src/main/java/io/sentry/ProfileChunk.java
@@ -1,5 +1,7 @@
 package io.sentry;
 
+import static io.sentry.DateUtils.doubleToBigDecimal;
+
 import io.sentry.profilemeasurements.ProfileMeasurement;
 import io.sentry.protocol.DebugMeta;
 import io.sentry.protocol.SdkVersion;
@@ -8,8 +10,6 @@
 import io.sentry.vendor.gson.stream.JsonToken;
 import java.io.File;
 import java.io.IOException;
-import java.math.BigDecimal;
-import java.math.RoundingMode;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
@@ -264,10 +264,6 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
     writer.endObject();
   }
 
-  private @NotNull BigDecimal doubleToBigDecimal(final @NotNull Double value) {
-    return BigDecimal.valueOf(value).setScale(6, RoundingMode.DOWN);
-  }
-
   @Nullable
   @Override
   public Map<String, Object> getUnknown() {
diff --git a/sentry/src/main/java/io/sentry/profilemeasurements/ProfileMeasurementValue.java b/sentry/src/main/java/io/sentry/profilemeasurements/ProfileMeasurementValue.java
index 2f9ba5e1312..d27114c66ef 100644
--- a/sentry/src/main/java/io/sentry/profilemeasurements/ProfileMeasurementValue.java
+++ b/sentry/src/main/java/io/sentry/profilemeasurements/ProfileMeasurementValue.java
@@ -1,5 +1,7 @@
 package io.sentry.profilemeasurements;
 
+import static io.sentry.DateUtils.doubleToBigDecimal;
+
 import io.sentry.DateUtils;
 import io.sentry.ILogger;
 import io.sentry.JsonDeserializer;
@@ -10,8 +12,6 @@
 import io.sentry.util.Objects;
 import io.sentry.vendor.gson.stream.JsonToken;
 import java.io.IOException;
-import java.math.BigDecimal;
-import java.math.RoundingMode;
 import java.util.Date;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
@@ -92,10 +92,6 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
     writer.endObject();
   }
 
-  private @NotNull BigDecimal doubleToBigDecimal(final @NotNull Double value) {
-    return BigDecimal.valueOf(value).setScale(6, RoundingMode.DOWN);
-  }
-
   @Nullable
   @Override
   public Map<String, Object> getUnknown() {
diff --git a/sentry/src/main/java/io/sentry/protocol/SentrySpan.java b/sentry/src/main/java/io/sentry/protocol/SentrySpan.java
index 6274c8b00d7..58930ec1a87 100644
--- a/sentry/src/main/java/io/sentry/protocol/SentrySpan.java
+++ b/sentry/src/main/java/io/sentry/protocol/SentrySpan.java
@@ -1,5 +1,7 @@
 package io.sentry.protocol;
 
+import static io.sentry.DateUtils.doubleToBigDecimal;
+
 import io.sentry.DateUtils;
 import io.sentry.ILogger;
 import io.sentry.JsonDeserializer;
@@ -16,8 +18,6 @@
 import io.sentry.util.Objects;
 import io.sentry.vendor.gson.stream.JsonToken;
 import java.io.IOException;
-import java.math.BigDecimal;
-import java.math.RoundingMode;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
@@ -230,10 +230,6 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
     writer.endObject();
   }
 
-  private @NotNull BigDecimal doubleToBigDecimal(final @NotNull Double value) {
-    return BigDecimal.valueOf(value).setScale(6, RoundingMode.DOWN);
-  }
-
   @Nullable
   @Override
   public Map<String, Object> getUnknown() {
diff --git a/sentry/src/main/java/io/sentry/protocol/profiling/SentrySample.java b/sentry/src/main/java/io/sentry/protocol/profiling/SentrySample.java
index 8f1c95641d5..af9053742d3 100644
--- a/sentry/src/main/java/io/sentry/protocol/profiling/SentrySample.java
+++ b/sentry/src/main/java/io/sentry/protocol/profiling/SentrySample.java
@@ -1,5 +1,7 @@
 package io.sentry.protocol.profiling;
 
+import static io.sentry.DateUtils.doubleToBigDecimal;
+
 import io.sentry.ILogger;
 import io.sentry.JsonDeserializer;
 import io.sentry.JsonSerializable;
@@ -8,8 +10,6 @@
 import io.sentry.ObjectWriter;
 import io.sentry.vendor.gson.stream.JsonToken;
 import java.io.IOException;
-import java.math.BigDecimal;
-import java.math.RoundingMode;
 import java.util.HashMap;
 import java.util.Map;
 import org.jetbrains.annotations.ApiStatus;
@@ -78,10 +78,6 @@ public void serialize(@NotNull ObjectWriter writer, @NotNull ILogger logger) thr
     writer.endObject();
   }
 
-  private @NotNull BigDecimal doubleToBigDecimal(final @NotNull Double value) {
-    return BigDecimal.valueOf(value).setScale(6, RoundingMode.DOWN);
-  }
-
   @Nullable
   @Override
   public Map<String, Object> getUnknown() {

From 06b0d8089c88819b4be74dd8eeff4aba34e9877b Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Wed, 17 Jun 2026 14:39:28 +0200
Subject: [PATCH 208/391] chore(android-sqlite): Repair start times of spans
 generated by SentrySQLiteDriver (#5543)

chore(android-sqlite): Repair start times of spans generated by SentrySQLiteDriver (JAVA-275)

Repairs the nanoTimetamp of the SentryNanotimeDates used as start times for the spans generated by SentrySQLiteDriver. Without those repairs, all spans within a given wall clock millisecond are displayed by Sentry UI as starting at that same millisecond and are re-ordered arbitrarily. Often that's quite confusing as actual BEGIN -> EXECUTE STATEMENT -> END sequences can appear as EXECUTE STATEMENT -> END -> BEGIN (etc.).

For more details, see the discussion [here](https://github.com/getsentry/sentry-java/pull/5504#issuecomment-4679631245).
---
 .../android/sqlite/SQLiteSpanManager.kt       |  43 +++++--
 .../main/java/io/sentry/sqlite/DbMetadata.kt  |  11 --
 .../sqlite/SQLiteSpanInstrumentation.kt       | 101 ++++++++++------
 .../io/sentry/sqlite/SentrySQLiteStatement.kt |  13 +-
 .../ComputeNanoStartTimestampForChildTest.kt  | 100 ++++++++++++++++
 .../java/io/sentry/sqlite/DbMetadataTest.kt   |   8 --
 .../sqlite/SQLiteSpanInstrumentationTest.kt   | 112 +++++++++++-------
 .../sqlite/SentrySQLiteStatementTest.kt       |   9 +-
 8 files changed, 279 insertions(+), 118 deletions(-)
 create mode 100644 sentry-android-sqlite/src/test/java/io/sentry/sqlite/ComputeNanoStartTimestampForChildTest.kt

diff --git a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt
index 3495d3a71f0..1bdeb7d369c 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt
@@ -3,17 +3,21 @@ package io.sentry.android.sqlite
 import android.database.CrossProcessCursor
 import android.database.SQLException
 import io.sentry.IScopes
+import io.sentry.ISpan
+import io.sentry.Instrumenter
 import io.sentry.ScopesAdapter
 import io.sentry.SentryIntegrationPackageStorage
+import io.sentry.SentryStackTraceFactory
+import io.sentry.SpanDataConvention
 import io.sentry.SpanStatus
-import io.sentry.sqlite.SQLiteSpanInstrumentation
+
+private const val TRACE_ORIGIN = "auto.db.sqlite"
 
 internal class SQLiteSpanManager(
   private val scopes: IScopes = ScopesAdapter.getInstance(),
-  databaseName: String? = null,
+  private val databaseName: String? = null,
 ) {
-
-  private val spans = SQLiteSpanInstrumentation.fromDatabaseName(databaseName, scopes)
+  private val stackTraceFactory = SentryStackTraceFactory(scopes.options)
 
   init {
     SentryIntegrationPackageStorage.getInstance().addIntegration("SQLite")
@@ -29,8 +33,8 @@ internal class SQLiteSpanManager(
   @Suppress("TooGenericExceptionCaught", "UNCHECKED_CAST")
   @Throws(SQLException::class)
   fun <T> performSql(sql: String, operation: () -> T): T {
-    val startTimestamp = spans.startTimestamp()
-
+    val startTimestamp = scopes.getOptions().dateProvider.now()
+    var span: ISpan? = null
     return try {
       val result = operation()
       /*
@@ -41,11 +45,34 @@ internal class SQLiteSpanManager(
       if (result is CrossProcessCursor) {
         return SentryCrossProcessCursor(result, this, sql) as T
       }
-      spans.recordSpan(sql, startTimestamp, SpanStatus.OK)
+      span = scopes.span?.startChild("db.sql.query", sql, startTimestamp, Instrumenter.SENTRY)
+      span?.spanContext?.origin = TRACE_ORIGIN
+      span?.status = SpanStatus.OK
       result
     } catch (e: Throwable) {
-      spans.recordSpan(sql, startTimestamp, SpanStatus.INTERNAL_ERROR, e)
+      span = scopes.span?.startChild("db.sql.query", sql, startTimestamp, Instrumenter.SENTRY)
+      span?.spanContext?.origin = TRACE_ORIGIN
+      span?.status = SpanStatus.INTERNAL_ERROR
+      span?.throwable = e
       throw e
+    } finally {
+      span?.apply {
+        val isMainThread: Boolean = scopes.options.threadChecker.isMainThread
+        setData(SpanDataConvention.BLOCKED_MAIN_THREAD_KEY, isMainThread)
+        if (isMainThread) {
+          setData(SpanDataConvention.CALL_STACK_KEY, stackTraceFactory.inAppCallStack)
+        }
+        // if db name is null, then it's an in-memory database as per
+        // https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:sqlite/sqlite/src/main/java/androidx/sqlite/db/SupportSQLiteOpenHelper.kt;l=38-42
+        if (databaseName != null) {
+          setData(SpanDataConvention.DB_SYSTEM_KEY, "sqlite")
+          setData(SpanDataConvention.DB_NAME_KEY, databaseName)
+        } else {
+          setData(SpanDataConvention.DB_SYSTEM_KEY, "in-memory")
+        }
+
+        finish()
+      }
     }
   }
 }
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/DbMetadata.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/DbMetadata.kt
index aa3c186b6d9..598dc524ed1 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/DbMetadata.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/DbMetadata.kt
@@ -36,14 +36,3 @@ internal fun dbMetadataFromFileName(fileName: String): DbMetadata {
   val basename = if (index >= 0) trimmed.substring(index + 1) else trimmed
   return DbMetadata(name = basename.ifEmpty { null }, system = DB_SYSTEM_SQLITE)
 }
-
-/**
- * Returns metadata based on
- * [SupportSQLiteOpenHelper.databaseName][androidx.sqlite.db.SupportSQLiteOpenHelper.databaseName].
- */
-internal fun dbMetadataFromDatabaseName(databaseName: String?): DbMetadata =
-  if (databaseName == null) {
-    DbMetadata(name = null, system = DB_SYSTEM_IN_MEMORY)
-  } else {
-    DbMetadata(name = databaseName, system = DB_SYSTEM_SQLITE)
-  }
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
index 4c925198bd5..5099f38f691 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
@@ -1,17 +1,26 @@
 package io.sentry.sqlite
 
 import io.sentry.IScopes
+import io.sentry.ISpan
 import io.sentry.Instrumenter
 import io.sentry.ScopesAdapter
 import io.sentry.SentryDate
 import io.sentry.SentryLongDate
+import io.sentry.SentryNanotimeDate
 import io.sentry.SentryStackTraceFactory
 import io.sentry.SpanDataConvention
 import io.sentry.SpanStatus
+import java.util.Date
 
 private const val SQLITE_TRACE_ORIGIN = "auto.db.sqlite"
 
-/** Shared span instrumentation for SQLite. */
+/**
+ * Sentinel for extracting a [SentryNanotimeDate]'s underlying [System.nanoTime] value via
+ * [SentryDate.diff].
+ */
+private val EMPTY_NANO_TIME = SentryNanotimeDate(Date(0), 0L)
+
+/** Span instrumentation for [SentrySQLiteDriver]. */
 internal class SQLiteSpanInstrumentation(
   private val scopes: IScopes,
   private val dbMetadata: DbMetadata,
@@ -20,44 +29,32 @@ internal class SQLiteSpanInstrumentation(
   private val stackTraceFactory = SentryStackTraceFactory(scopes.options)
 
   /**
-   * Returns a start timestamp for a `db.sql.query` span.
+   * Returns a timestamp in nanoseconds for use with [recordSpan]. Timestamp is ns-precise if the
+   * active parent span uses a [SentryNanotimeDate] (the ordinary case); otherwise it's ms-precise.
    *
-   * Exposed so callers can capture a wall-clock start before accumulating database time.
-   * Internalizing the start time in [recordSpan] would shift spans to end-of-work on the trace
-   * timeline, which is less desirable.
+   * Note: Internalizing the start time in [recordSpan] would shift spans to end-of-work on the
+   * trace timeline, which is less desirable; callers capture the start before doing database work
+   * and pass it back to [recordSpan].
    */
-  fun startTimestamp(): SentryDate = scopes.options.dateProvider.now()
-
-  /** Records a `db.sql.query` span from [startTimestamp] to the moment of invocation. */
-  fun recordSpan(
-    sql: String,
-    startTimestamp: SentryDate,
-    status: SpanStatus,
-    throwable: Throwable? = null,
-  ) {
-    recordSpan(sql, startTimestamp, endTimestamp = null, status, throwable)
-  }
+  fun startTimestamp(): Long =
+    // Try to retain nanosecond precision + avoid SentryDate allocation...
+    scopes.span?.computeNanoStartTimestampForChild()
+      // ...otherwise fall back to millisecond precision + allocate.
+      ?: scopes.options.dateProvider.now().nanoTimestamp()
 
-  /** Records a `db.sql.query` span from [startTimestamp] to [startTimestamp] + [durationNanos]. */
+  /** Records a `db.sql.query` span. */
   fun recordSpan(
     sql: String,
-    startTimestamp: SentryDate,
+    startTimestampNanos: Long,
     durationNanos: Long,
     status: SpanStatus,
     throwable: Throwable? = null,
   ) {
-    val endTimestamp = SentryLongDate(startTimestamp.nanoTimestamp() + durationNanos)
-    recordSpan(sql, startTimestamp, endTimestamp, status, throwable)
-  }
+    val parent = scopes.span ?: return
+    val startTimestamp = SentryLongDate(startTimestampNanos)
+    val endTimestamp = SentryLongDate(startTimestampNanos + durationNanos)
 
-  private fun recordSpan(
-    sql: String,
-    startTimestamp: SentryDate,
-    endTimestamp: SentryDate?,
-    status: SpanStatus,
-    throwable: Throwable?,
-  ) {
-    scopes.span?.startChild("db.sql.query", sql, startTimestamp, Instrumenter.SENTRY)?.apply {
+    parent.startChild("db.sql.query", sql, startTimestamp, Instrumenter.SENTRY).apply {
       spanContext.origin = SQLITE_TRACE_ORIGIN
       throwable?.let { this.throwable = it }
 
@@ -85,15 +82,43 @@ internal class SQLiteSpanInstrumentation(
       scopes: IScopes = ScopesAdapter.getInstance(),
     ): SQLiteSpanInstrumentation =
       SQLiteSpanInstrumentation(scopes, dbMetadataFromFileName(fileName))
+  }
+}
 
-    /**
-     * Returns [SQLiteSpanInstrumentation] based on
-     * [SupportSQLiteOpenHelper.databaseName][androidx.sqlite.db.SupportSQLiteOpenHelper.databaseName].
-     */
-    fun fromDatabaseName(
-      databaseName: String?,
-      scopes: IScopes = ScopesAdapter.getInstance(),
-    ): SQLiteSpanInstrumentation =
-      SQLiteSpanInstrumentation(scopes, dbMetadataFromDatabaseName(databaseName))
+/**
+ * Computes a start timestamp with nanosecond precision for the child of the receiver span. Returns
+ * null if nanosecond precision isn't possible.
+ *
+ * Lets us improve the display of spans in the Sentry UI. If timestamps are only ms-precise, the
+ * Sentry UI will left-align and arbitrarily reorder spans that share the same wall clock ms:
+ * ```
+ *                                  (Relative start times out of order)
+ *                                                ↓
+ * Parent span                 ├█████████████┤
+ * END TRANSACTION              ├███┤          0.33 ms
+ * BEGIN IMMEDIATE TRANSACTION  ├████┤         0.02 ms
+ * INSERT INTO `my_db` …        ├██┤           0.30 ms
+ *                              ↑
+ *               (All spans share the same ms baseline
+ *             even though their execution was staggered)
+ * ```
+ *
+ * Nanosecond precision ensures proper ordering and lets the spans stagger:
+ * ```
+ * Parent span                 ├█████████████┤
+ * BEGIN IMMEDIATE TRANSACTION  ├████┤         0.02 ms
+ * INSERT INTO `my_db` …              ├██┤     0.30 ms
+ * END TRANSACTION                     ├███┤   0.33 ms
+ * ```
+ */
+internal fun ISpan.computeNanoStartTimestampForChild(): Long? {
+  if (startDate !is SentryNanotimeDate) {
+    return null
   }
+
+  val parentWallClockNanos = startDate.nanoTimestamp()
+  val parentMonotonicNanos = startDate.diff(EMPTY_NANO_TIME)
+  val elapsedSinceParentStart = System.nanoTime() - parentMonotonicNanos
+  // Return the child's absolute start time.
+  return parentWallClockNanos + elapsedSinceParentStart
 }
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt
index 41df37444b5..a739a396bcb 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt
@@ -1,7 +1,6 @@
 package io.sentry.sqlite
 
 import androidx.sqlite.SQLiteStatement
-import io.sentry.SentryDate
 import io.sentry.SpanStatus
 
 /**
@@ -22,7 +21,7 @@ internal class SentrySQLiteStatement(
   private val nanoTimeProvider: () -> Long = { System.nanoTime() },
 ) : SQLiteStatement by delegate {
 
-  private var firstStepTimestamp: SentryDate? = null
+  private var firstStepTimestampNanos: Long? = null
   private var accumulatedDbNanos: Long = 0L
   private var stepsComplete = false
   private var closed = false
@@ -35,8 +34,8 @@ internal class SentrySQLiteStatement(
 
     val beforeNanos = nanoTimeProvider()
     return try {
-      if (firstStepTimestamp == null) {
-        firstStepTimestamp = spans.startTimestamp()
+      if (firstStepTimestampNanos == null) {
+        firstStepTimestampNanos = spans.startTimestamp()
       }
 
       stepsComplete = !delegate.step()
@@ -71,10 +70,10 @@ internal class SentrySQLiteStatement(
   }
 
   private fun recordSpan(status: SpanStatus, throwable: Throwable? = null) {
-    val start = firstStepTimestamp ?: return
+    val startNanos = firstStepTimestampNanos ?: return
     val duration = accumulatedDbNanos
-    firstStepTimestamp = null
+    firstStepTimestampNanos = null
     accumulatedDbNanos = 0L
-    spans.recordSpan(sql, start, duration, status, throwable)
+    spans.recordSpan(sql, startNanos, duration, status, throwable)
   }
 }
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/ComputeNanoStartTimestampForChildTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/ComputeNanoStartTimestampForChildTest.kt
new file mode 100644
index 00000000000..92a98b6e56d
--- /dev/null
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/ComputeNanoStartTimestampForChildTest.kt
@@ -0,0 +1,100 @@
+package io.sentry.sqlite
+
+import io.sentry.DateUtils
+import io.sentry.ISpan
+import io.sentry.SentryLongDate
+import io.sentry.SentryNanotimeDate
+import java.util.Date
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+class ComputeNanoStartTimestampForChildTest {
+
+  @Test
+  fun `returns parent wall clock plus elapsed monotonic time since parent started`() {
+    val wallClockMillis = 1_000_000L
+    val elapsedNanos = 500_000L
+    val parentMonotonicNanos = System.nanoTime() - elapsedNanos
+    val span = spanWithNanotimeStart(wallClockMillis, parentMonotonicNanos)
+
+    val timestamp = span.computeNanoStartTimestampForChild()!!
+
+    val elapsedSinceParentStart = timestamp - DateUtils.millisToNanos(wallClockMillis)
+    assertTrue(elapsedSinceParentStart >= elapsedNanos)
+    assertTrue(elapsedSinceParentStart < elapsedNanos + TEST_SLACK_NANOS)
+  }
+
+  @Test
+  fun `same millisecond wall clocks with different monotonic offsets produce distinct ordered timestamps`() {
+    val wallClockMillis = 1_000_000L
+    val wallClockNanos = DateUtils.millisToNanos(wallClockMillis)
+    val earlierParentMonotonicNanos = System.nanoTime() - 200_000L
+    val laterParentMonotonicNanos = System.nanoTime() - 800_000L
+    val earlierSpan = spanWithNanotimeStart(wallClockMillis, earlierParentMonotonicNanos)
+    val laterSpan = spanWithNanotimeStart(wallClockMillis, laterParentMonotonicNanos)
+
+    assertEquals(
+      earlierSpan.startDate.nanoTimestamp(),
+      laterSpan.startDate.nanoTimestamp(),
+      "Raw parent timestamps share the same ms-quantized value",
+    )
+
+    val earlier = earlierSpan.computeNanoStartTimestampForChild()!!
+    val later = laterSpan.computeNanoStartTimestampForChild()!!
+
+    assertTrue(earlier > wallClockNanos)
+    assertTrue(later > wallClockNanos)
+    assertTrue(earlier < later)
+    assertTrue(later - earlier >= 500_000L)
+  }
+
+  @Test
+  fun `returns parent wall clock when no monotonic time has elapsed since parent started`() {
+    val wallClockMillis = 1_000_000L
+    val parentMonotonicNanos = System.nanoTime()
+    val span = spanWithNanotimeStart(wallClockMillis, parentMonotonicNanos)
+
+    val elapsedSinceParentStart =
+      span.computeNanoStartTimestampForChild()!! - DateUtils.millisToNanos(wallClockMillis)
+    assertTrue(elapsedSinceParentStart >= 0L)
+    assertTrue(elapsedSinceParentStart < TEST_SLACK_NANOS)
+  }
+
+  @Test
+  fun `works when parent wall clock differs from millisecond baseline`() {
+    val wallClockMillis = 1_000_001L
+    val elapsedNanos = 1_500_000L
+    val parentMonotonicNanos = System.nanoTime() - elapsedNanos
+    val span = spanWithNanotimeStart(wallClockMillis, parentMonotonicNanos)
+
+    val elapsedSinceParentStart =
+      span.computeNanoStartTimestampForChild()!! - DateUtils.millisToNanos(wallClockMillis)
+    assertTrue(elapsedSinceParentStart >= elapsedNanos)
+    assertTrue(elapsedSinceParentStart < elapsedNanos + TEST_SLACK_NANOS)
+  }
+
+  @Test
+  fun `returns null when start date is not SentryNanotimeDate`() {
+    val span = mock<ISpan>()
+    whenever(span.startDate).thenReturn(SentryLongDate(DateUtils.millisToNanos(1_000_000L)))
+
+    assertNull(span.computeNanoStartTimestampForChild())
+  }
+
+  private fun spanWithNanotimeStart(wallClockMillis: Long, parentMonotonicNanos: Long): ISpan {
+    val startDate = SentryNanotimeDate(Date(wallClockMillis), parentMonotonicNanos)
+    val span = mock<ISpan>()
+    whenever(span.startDate).thenReturn(startDate)
+    return span
+  }
+
+  companion object {
+
+    // Upper bound for monotonic drift while the test body runs.
+    private const val TEST_SLACK_NANOS = 50_000_000L
+  }
+}
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/DbMetadataTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/DbMetadataTest.kt
index 227b9d9558c..09d80793ed2 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/DbMetadataTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/DbMetadataTest.kt
@@ -13,14 +13,6 @@ class DbMetadataTest {
     )
   }
 
-  @Test
-  fun `dbMetadataFromDatabaseName returns in-memory system with no db name when databaseName is null`() {
-    assertEquals(
-      DbMetadata(name = null, system = DB_SYSTEM_IN_MEMORY),
-      dbMetadataFromDatabaseName(null),
-    )
-  }
-
   @Test
   fun `dbMetadataFromFileName returns sqlite system and db name for unix path`() {
     assertEquals(
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
index ead123a190b..a38be242ec5 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
@@ -1,15 +1,21 @@
 package io.sentry.sqlite
 
 import io.sentry.IScopes
+import io.sentry.ISpan
+import io.sentry.SentryDateProvider
+import io.sentry.SentryLongDate
+import io.sentry.SentryNanotimeDate
 import io.sentry.SentryOptions
 import io.sentry.SentryTracer
 import io.sentry.SpanDataConvention
 import io.sentry.SpanStatus
 import io.sentry.TransactionContext
 import io.sentry.util.thread.IThreadChecker
+import java.util.Date
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertIs
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
@@ -40,6 +46,63 @@ class SQLiteSpanInstrumentationTest {
 
   private val fixture = Fixture()
 
+  @Test
+  fun `startTimestamp is ns-precise and skips date provider when parent uses SentryNanotimeDate`() {
+    // Only the parent date is queued. If startTimestamp() were to call dateProvider.now(),
+    // the queue would underflow and the test would fail loudly — this is what verifies the
+    // optimization is in effect.
+    val parentDate = SentryNanotimeDate(Date(1_000_000L), 100_000_000L)
+    val sut = setUpWithNanotimeDates(parentDate)
+
+    val start = sut.startTimestamp()
+
+    val durationNanos = 42_000_000L
+    sut.recordSpan("SELECT 1", start, durationNanos, SpanStatus.OK)
+
+    val span = fixture.sentryTracer.children.first()
+
+    // startTimestamp returns an already-ns-precise value, anchored to the parent's wall clock and
+    // offset by elapsed System.nanoTime(). The exact ns-math is unit-tested in
+    // ChildStartTimestampOrNullTest; here we verify the integration shape.
+    assertIs<SentryLongDate>(span.startDate)
+    assertEquals(start, span.startDate.nanoTimestamp())
+    assertEquals(start + durationNanos, span.finishDate!!.nanoTimestamp())
+  }
+
+  @Test
+  fun `startTimestamp falls back to date provider when parent does not use SentryNanotimeDate`() {
+    val providerDate = SentryNanotimeDate(Date(2_000_000L), 200_000_000L)
+    val parentSpan = mock<ISpan>()
+    whenever(parentSpan.startDate).thenReturn(SentryLongDate(1_000_000_000_000_000L))
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        dateProvider = SentryDateProvider { providerDate }
+      }
+    whenever(fixture.scopes.options).thenReturn(options)
+    whenever(fixture.scopes.span).thenReturn(parentSpan)
+
+    val sut = SQLiteSpanInstrumentation.fromFileName(":memory:", fixture.scopes)
+
+    assertEquals(providerDate.nanoTimestamp(), sut.startTimestamp())
+  }
+
+  @Test
+  fun `startTimestamp falls back to date provider when no transaction is active`() {
+    val providerDate = SentryNanotimeDate(Date(2_000_000L), 200_000_000L)
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        dateProvider = SentryDateProvider { providerDate }
+      }
+    whenever(fixture.scopes.options).thenReturn(options)
+    whenever(fixture.scopes.span).thenReturn(null)
+
+    val sut = SQLiteSpanInstrumentation.fromFileName(":memory:", fixture.scopes)
+
+    assertEquals(providerDate.nanoTimestamp(), sut.startTimestamp())
+  }
+
   @Test
   fun `recordSpan records a span if a transaction is active`() {
     val sut = fixture.getSut(isTransactionActive = true)
@@ -79,7 +142,6 @@ class SQLiteSpanInstrumentationTest {
     sut.recordSpan("SELECT 1", start, durationNanos, SpanStatus.OK)
 
     val span = fixture.sentryTracer.children.first()
-    assertEquals(start, span.startDate)
     assertEquals(span.startDate.nanoTimestamp() + durationNanos, span.finishDate!!.nanoTimestamp())
   }
 
@@ -146,48 +208,16 @@ class SQLiteSpanInstrumentationTest {
     assertNull(span.getData(SpanDataConvention.CALL_STACK_KEY))
   }
 
-  @Test
-  fun `recordSpan without a duration finishes the span at the time of invocation`() {
-    val sut = fixture.getSut()
-    val start = sut.startTimestamp()
-
-    sut.recordSpan("SELECT 1", start, SpanStatus.OK)
-
-    val span = fixture.sentryTracer.children.first()
-    assertTrue(span.isFinished)
-    assertEquals(SpanStatus.OK, span.status)
-    // Unlike the duration overload, no synthetic end timestamp is supplied; the span finishes at
-    // "now", i.e. at or after its start.
-    assertTrue(span.finishDate!!.nanoTimestamp() >= start.nanoTimestamp())
-  }
-
-  @Test
-  fun `fromFileName sets db name from fileName`() {
-    val options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
-    whenever(fixture.scopes.options).thenReturn(options)
-    fixture.sentryTracer = SentryTracer(TransactionContext("name", "op"), fixture.scopes)
-    whenever(fixture.scopes.span).thenReturn(fixture.sentryTracer)
-
-    val sut = SQLiteSpanInstrumentation.fromFileName("tracks.db", fixture.scopes)
-    sut.recordSpan("SELECT 1", sut.startTimestamp(), SpanStatus.OK)
-
-    val span = fixture.sentryTracer.children.first()
-    assertEquals("sqlite", span.data[SpanDataConvention.DB_SYSTEM_KEY])
-    assertEquals("tracks.db", span.data[SpanDataConvention.DB_NAME_KEY])
-  }
-
-  @Test
-  fun `fromDatabaseName sets db name from databaseName`() {
-    val options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
+  private fun setUpWithNanotimeDates(vararg dates: SentryNanotimeDate): SQLiteSpanInstrumentation {
+    val dateQueue = ArrayDeque(dates.toList())
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        dateProvider = SentryDateProvider { dateQueue.removeFirst() }
+      }
     whenever(fixture.scopes.options).thenReturn(options)
     fixture.sentryTracer = SentryTracer(TransactionContext("name", "op"), fixture.scopes)
     whenever(fixture.scopes.span).thenReturn(fixture.sentryTracer)
-
-    val sut = SQLiteSpanInstrumentation.fromDatabaseName("tracks.db", fixture.scopes)
-    sut.recordSpan("SELECT 1", sut.startTimestamp(), SpanStatus.OK)
-
-    val span = fixture.sentryTracer.children.first()
-    assertEquals("sqlite", span.data[SpanDataConvention.DB_SYSTEM_KEY])
-    assertEquals("tracks.db", span.data[SpanDataConvention.DB_NAME_KEY])
+    return SQLiteSpanInstrumentation.fromFileName(":memory:", fixture.scopes)
   }
 }
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt
index 6691910e358..ce2c3f00cd5 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt
@@ -1,7 +1,6 @@
 package io.sentry.sqlite
 
 import androidx.sqlite.SQLiteStatement
-import io.sentry.SentryLongDate
 import io.sentry.SpanStatus
 import java.util.concurrent.atomic.AtomicLong
 import kotlin.test.Test
@@ -21,11 +20,11 @@ class SentrySQLiteStatementTest {
   private class Fixture {
     val mockStatement = mock<SQLiteStatement>()
     val mockSpans = mock<SQLiteSpanInstrumentation>()
-    val startDate = SentryLongDate(1_000_000_000_000L)
+    val startTimestampNanos = 1_000_000_000_000L
     val fakeClock = AtomicLong(0L)
 
     fun getSut(sql: String): SentrySQLiteStatement {
-      whenever(mockSpans.startTimestamp()).thenReturn(startDate)
+      whenever(mockSpans.startTimestamp()).thenReturn(startTimestampNanos)
       return SentrySQLiteStatement(mockStatement, mockSpans, sql, fakeClock::getAndIncrement)
     }
   }
@@ -43,7 +42,7 @@ class SentrySQLiteStatementTest {
     verify(fixture.mockSpans)
       .recordSpan(
         eq("SELECT * FROM users"),
-        eq(fixture.startDate),
+        eq(fixture.startTimestampNanos),
         any(),
         eq(SpanStatus.OK),
         anyOrNull(),
@@ -61,7 +60,7 @@ class SentrySQLiteStatementTest {
     verify(fixture.mockSpans)
       .recordSpan(
         eq("BAD SQL"),
-        eq(fixture.startDate),
+        eq(fixture.startTimestampNanos),
         any(),
         eq(SpanStatus.INTERNAL_ERROR),
         eq(exception),

From 3a7603a26335e1f1aafb78c75b4f1079819b25b3 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 17 Jun 2026 15:45:35 +0200
Subject: [PATCH 209/391] perf(android): Replace Date with unix timestamp in
 SentryNanotimeDate (JAVA-533) (#5550)

* perf(android): Replace Date with unix timestamp in SentryNanotimeDate (JAVA-533)

SentryNanotimeDate stored a java.util.Date but only ever read its epoch
millis. Storing the millis directly avoids a Calendar allocation on every
timestamp, which on Android backs every span/transaction timestamp.

The default constructor now uses System.currentTimeMillis() instead of
DateUtils.getCurrentDateTime() (Calendar with UTC). This is behavior-
preserving: the UTC TimeZone only affects calendar field access, not the
epoch-millis value the class used.

BREAKING: the public SentryNanotimeDate(Date, long) constructor is
replaced by SentryNanotimeDate(long unixDate, long nanos).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* ref(android): Mark SentryNanotimeDate as @ApiStatus.Internal

SentryNanotimeDate is the legacy Date+nanoTime precision workaround and is
not intended for direct use by consumers. Marking it @ApiStatus.Internal
signals this and means the constructor change in this PR is not a public
API break per the repo's API policy.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(sentry): Rename unixDate field to unixDateMillis

Name the long field for its unit so it is clear it holds the unix
timestamp in milliseconds since the epoch.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(changelog): Reword SentryNanotimeDate entry

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(sentry): Restore deprecated SentryNanotimeDate Date constructor (JAVA-533)

The previous change replaced the (Date, long) constructor with a
(long, long) constructor, which was a breaking API change. Add the
Date constructor back, delegating to the millis-based one, and mark
it deprecated to steer callers toward the new constructor.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(sentry): Suppress InlineMeSuggester on deprecated constructor (JAVA-533)

Error Prone flagged the deprecated (Date, long) constructor as
inlineable, failing the build. Suppress the suggestion to match the
existing convention in Sentry.java, keeping the constructor available
for backwards compatibility.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(sentry): Suppress JavaUtilDate on deprecated constructor (JAVA-533)

Error Prone's JavaUtilDate check flagged date.getTime() in the
deprecated constructor, failing the build. Suppress it, matching the
existing suppression used elsewhere in this class.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  2 +
 .../core/ActivityLifecycleIntegration.java    |  5 +-
 .../core/SpanFrameMetricsCollector.java       |  3 +-
 .../core/ActivityLifecycleIntegrationTest.kt  | 67 +++++++++----------
 .../core/NetworkBreadcrumbsIntegrationTest.kt |  6 +-
 .../core/SpanFrameMetricsCollectorTest.kt     | 15 +++--
 .../ActivityLifecycleSpanHelperTest.kt        |  9 ++-
 .../core/performance/AppStartMetricsTest.kt   |  3 +-
 .../apache/ApacheHttpClientTransportTest.kt   |  4 +-
 sentry/api/sentry.api                         |  2 +-
 sentry/src/main/java/io/sentry/DateUtils.java | 11 ---
 .../java/io/sentry/SentryNanotimeDate.java    | 29 +++++---
 ...efaultCompositePerformanceCollectorTest.kt | 21 ++----
 .../java/io/sentry/SentryNanotimeDateTest.kt  | 29 ++++----
 .../test/java/io/sentry/SentryTracerTest.kt   |  5 +-
 .../transport/AsyncHttpTransportTest.kt       |  4 +-
 16 files changed, 99 insertions(+), 116 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5dbcde58f10..0de5fc72452 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,8 @@
 ### Improvements
 
 - Reduce boxing to improve performance ([#5523](https://github.com/getsentry/sentry-java/pull/5523), [#5527](https://github.com/getsentry/sentry-java/pull/5527), [#5551](https://github.com/getsentry/sentry-java/pull/5551))
+- Replace `Date` with a unix timestamp in `SentryNanotimeDate` to improve performance ([#5550](https://github.com/getsentry/sentry-java/pull/5550))
+  - `SentryNanotimeDate` is now marked `@ApiStatus.Internal`. A new `(long unixDateMillis, long nanos)` constructor was added, where `unixDateMillis` is milliseconds since the epoch. The existing `(Date, long)` constructor is retained but deprecated.
 
 ### Dependencies
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
index 19cee7fcce5..8a891926341 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
@@ -45,7 +45,6 @@
 import java.io.IOException;
 import java.lang.ref.WeakReference;
 import java.util.Collections;
-import java.util.Date;
 import java.util.Map;
 import java.util.WeakHashMap;
 import java.util.concurrent.Future;
@@ -94,7 +93,7 @@ public final class ActivityLifecycleIntegration
   private final @NotNull WeakHashMap<Activity, ISpan> ttfdSpanMap = new WeakHashMap<>();
   private final @NotNull WeakHashMap<Activity, ActivityLifecycleSpanHelper> activitySpanHelpers =
       new WeakHashMap<>();
-  private @NotNull SentryDate lastPausedTime = new SentryNanotimeDate(new Date(0), 0);
+  private @NotNull SentryDate lastPausedTime = new SentryNanotimeDate(0, 0);
   private @Nullable Future<?> ttfdAutoCloseFuture = null;
 
   // WeakHashMap isn't thread safe but ActivityLifecycleCallbacks is only called from the
@@ -729,7 +728,7 @@ public void onActivityDestroyed(final @NotNull Activity activity) {
 
   private void clear() {
     firstActivityCreated = false;
-    lastPausedTime = new SentryNanotimeDate(new Date(0), 0);
+    lastPausedTime = new SentryNanotimeDate(0, 0);
     activitySpanHelpers.clear();
   }
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SpanFrameMetricsCollector.java b/sentry-android-core/src/main/java/io/sentry/android/core/SpanFrameMetricsCollector.java
index a83454d29b7..074a4a6ea51 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SpanFrameMetricsCollector.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SpanFrameMetricsCollector.java
@@ -13,7 +13,6 @@
 import io.sentry.android.core.internal.util.SentryFrameMetricsCollector;
 import io.sentry.protocol.MeasurementValue;
 import io.sentry.util.AutoClosableReentrantLock;
-import java.util.Date;
 import java.util.Iterator;
 import java.util.SortedSet;
 import java.util.TreeSet;
@@ -33,7 +32,7 @@ public class SpanFrameMetricsCollector
   // grow indefinitely in case of a long running span
   private static final int MAX_FRAMES_COUNT = 3600;
   private static final long ONE_SECOND_NANOS = TimeUnit.SECONDS.toNanos(1);
-  private static final SentryNanotimeDate EMPTY_NANO_TIME = new SentryNanotimeDate(new Date(0), 0);
+  private static final SentryNanotimeDate EMPTY_NANO_TIME = new SentryNanotimeDate(0, 0);
 
   private final boolean enabled;
   protected final @NotNull AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
index f2ffb4b4b96..19f43432bef 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
@@ -41,7 +41,6 @@ import io.sentry.protocol.SentryId
 import io.sentry.protocol.TransactionNameSource
 import io.sentry.test.DeferredExecutorService
 import io.sentry.test.getProperty
-import java.util.Date
 import java.util.concurrent.Future
 import java.util.concurrent.TimeUnit
 import kotlin.test.AfterTest
@@ -936,7 +935,7 @@ class ActivityLifecycleIntegrationTest {
     sut.register(fixture.scopes, fixture.options)
     sut.setFirstActivityCreated(false)
 
-    val date = SentryNanotimeDate(Date(1), 0)
+    val date = SentryNanotimeDate(1, 0)
     setAppStartTime(date)
     fixture.options.dateProvider = SentryDateProvider { date }
 
@@ -961,7 +960,7 @@ class ActivityLifecycleIntegrationTest {
     sut.register(fixture.scopes, fixture.options)
     sut.setFirstActivityCreated(false)
 
-    val date = SentryNanotimeDate(Date(1), 0)
+    val date = SentryNanotimeDate(1, 0)
     setAppStartTime(date)
 
     val activity = mock<Activity>()
@@ -984,8 +983,8 @@ class ActivityLifecycleIntegrationTest {
     sut.register(fixture.scopes, fixture.options)
     sut.setFirstActivityCreated(false)
 
-    val date = SentryNanotimeDate(Date(1), 0)
-    val date2 = SentryNanotimeDate(Date(2), 2)
+    val date = SentryNanotimeDate(1, 0)
+    val date2 = SentryNanotimeDate(2, 2)
     setAppStartTime(date)
 
     val activity = mock<Activity>()
@@ -1011,7 +1010,7 @@ class ActivityLifecycleIntegrationTest {
     val sut = fixture.getSut { it.tracesSampleRate = 1.0 }
     sut.register(fixture.scopes, fixture.options)
     sut.setFirstActivityCreated(true)
-    val date = SentryNanotimeDate(Date(1), 0)
+    val date = SentryNanotimeDate(1, 0)
     setAppStartTime(date)
 
     val activity = mock<Activity>()
@@ -1030,8 +1029,8 @@ class ActivityLifecycleIntegrationTest {
     sut.setFirstActivityCreated(false)
 
     // usually set by SentryPerformanceProvider
-    val date = SentryNanotimeDate(Date(1), 0)
-    val date2 = SentryNanotimeDate(Date(2), 2)
+    val date = SentryNanotimeDate(1, 0)
+    val date2 = SentryNanotimeDate(2, 2)
 
     val activity = mock<Activity>()
     // Activity onCreate date will be used
@@ -1056,7 +1055,7 @@ class ActivityLifecycleIntegrationTest {
     sut.register(fixture.scopes, fixture.options)
 
     // usually set by SentryPerformanceProvider
-    val date = SentryNanotimeDate(Date(1), 0)
+    val date = SentryNanotimeDate(1, 0)
     setAppStartTime(date)
 
     val activity = mock<Activity>()
@@ -1080,7 +1079,7 @@ class ActivityLifecycleIntegrationTest {
     sut.register(fixture.scopes, fixture.options)
 
     // usually set by SentryPerformanceProvider
-    val startDate = SentryNanotimeDate(Date(1), 0)
+    val startDate = SentryNanotimeDate(1, 0)
     setAppStartTime(startDate)
     val appStartMetrics = AppStartMetrics.getInstance()
     appStartMetrics.appStartType = AppStartType.WARM
@@ -1113,9 +1112,9 @@ class ActivityLifecycleIntegrationTest {
         it.isEnableStandaloneAppStartTracing = true
       }
     sut.register(fixture.scopes, fixture.options)
-    val firstFrameDate = SentryNanotimeDate(Date(1499), 0)
+    val firstFrameDate = SentryNanotimeDate(1499, 0)
     fixture.options.dateProvider = SentryDateProvider { firstFrameDate }
-    setAppStartTime(SentryNanotimeDate(Date(1), 0))
+    setAppStartTime(SentryNanotimeDate(1, 0))
 
     val activity = mock<Activity>()
     sut.onActivityPreCreated(activity, fixture.bundle)
@@ -1168,8 +1167,8 @@ class ActivityLifecycleIntegrationTest {
         it.isEnableStandaloneAppStartTracing = true
       }
     sut.register(fixture.scopes, fixture.options)
-    val appStartEndDate = SentryNanotimeDate(Date(499), 0)
-    setAppStartTime(SentryNanotimeDate(Date(1), 0), appStartEndDate)
+    val appStartEndDate = SentryNanotimeDate(499, 0)
+    setAppStartTime(SentryNanotimeDate(1, 0), appStartEndDate)
 
     val activity = mock<Activity>()
     sut.onActivityPreCreated(activity, fixture.bundle)
@@ -1230,9 +1229,9 @@ class ActivityLifecycleIntegrationTest {
     AppStartMetrics.getInstance().appStartSentryTraceHeader =
       SentryTraceHeader(storedTraceId, SpanId(), true).value
     // headless start ended right before the activity opens
-    AppStartMetrics.getInstance().appStartEndTime = SentryNanotimeDate(Date(0), 0)
+    AppStartMetrics.getInstance().appStartEndTime = SentryNanotimeDate(0, 0)
     sut.register(fixture.scopes, fixture.options)
-    setAppStartTime(date = SentryNanotimeDate(Date(1), 0))
+    setAppStartTime(date = SentryNanotimeDate(1, 0))
 
     val activity = mock<Activity>()
     sut.onActivityCreated(activity, fixture.bundle)
@@ -1254,9 +1253,9 @@ class ActivityLifecycleIntegrationTest {
     AppStartMetrics.getInstance().appStartSentryTraceHeader =
       SentryTraceHeader(storedTraceId, SpanId(), true).value
     // headless start ended at epoch, but the activity opens more than a minute later
-    AppStartMetrics.getInstance().appStartEndTime = SentryNanotimeDate(Date(0), 0)
+    AppStartMetrics.getInstance().appStartEndTime = SentryNanotimeDate(0, 0)
     sut.register(fixture.scopes, fixture.options)
-    setAppStartTime(date = SentryNanotimeDate(Date(TimeUnit.MINUTES.toMillis(2)), 0))
+    setAppStartTime(date = SentryNanotimeDate(TimeUnit.MINUTES.toMillis(2), 0))
 
     val activity = mock<Activity>()
     sut.onActivityCreated(activity, fixture.bundle)
@@ -1389,7 +1388,7 @@ class ActivityLifecycleIntegrationTest {
 
     // usually done by SentryPerformanceProvider, if disabled it's done by
     // SentryAndroid.init
-    val startDate = SentryNanotimeDate(Date(1), 0)
+    val startDate = SentryNanotimeDate(1, 0)
     setAppStartTime(startDate)
     AppStartMetrics.getInstance().appStartType = AppStartType.WARM
 
@@ -1415,7 +1414,7 @@ class ActivityLifecycleIntegrationTest {
     sut.register(fixture.scopes, fixture.options)
 
     // usually done by SentryPerformanceProvider
-    val startDate = SentryNanotimeDate(Date(1), 0)
+    val startDate = SentryNanotimeDate(1, 0)
     setAppStartTime(startDate)
     AppStartMetrics.getInstance().appStartType = AppStartType.WARM
     AppStartMetrics.getInstance().sdkInitTimeSpan.setStoppedAt(1234)
@@ -1439,7 +1438,7 @@ class ActivityLifecycleIntegrationTest {
     sut.register(fixture.scopes, fixture.options)
 
     // usually done by SentryPerformanceProvider
-    val startDate = SentryNanotimeDate(Date(1), 0)
+    val startDate = SentryNanotimeDate(1, 0)
     setAppStartTime(startDate)
     AppStartMetrics.getInstance().appStartType = AppStartType.WARM
 
@@ -1474,7 +1473,7 @@ class ActivityLifecycleIntegrationTest {
     sut.register(fixture.scopes, fixture.options)
     sut.setFirstActivityCreated(true)
 
-    val date = SentryNanotimeDate(Date(1), 0)
+    val date = SentryNanotimeDate(1, 0)
     setAppStartTime()
 
     val activity = mock<Activity>()
@@ -1988,14 +1987,14 @@ class ActivityLifecycleIntegrationTest {
   @Test
   fun `When sentry is initialized mid activity lifecycle, last paused time should be used in favor of app start time`() {
     val sut = fixture.getSut(importance = RunningAppProcessInfo.IMPORTANCE_FOREGROUND)
-    val now = SentryNanotimeDate(Date(1234), 456)
+    val now = SentryNanotimeDate(1234, 456)
 
     fixture.options.tracesSampleRate = 1.0
     fixture.options.dateProvider = SentryDateProvider { now }
     sut.register(fixture.scopes, fixture.options)
 
     // usually done by SentryPerformanceProvider
-    val startDate = SentryNanotimeDate(Date(5678), 910)
+    val startDate = SentryNanotimeDate(5678, 910)
     setAppStartTime(startDate)
     AppStartMetrics.getInstance().appStartType = AppStartType.COLD
 
@@ -2019,7 +2018,7 @@ class ActivityLifecycleIntegrationTest {
     fixture.options.tracesSampleRate = 1.0
     sut.register(fixture.scopes, fixture.options)
 
-    val date = SentryNanotimeDate(Date(1), 0)
+    val date = SentryNanotimeDate(1, 0)
     setAppStartTime(date)
 
     assertTrue(sut.activitySpanHelpers.isEmpty())
@@ -2036,8 +2035,8 @@ class ActivityLifecycleIntegrationTest {
   fun `Creates activity lifecycle spans`() {
     val sut = fixture.getSut()
     fixture.options.tracesSampleRate = 1.0
-    val appStartDate = SentryNanotimeDate(Date(1), 0)
-    val startDate = SentryNanotimeDate(Date(2), 0)
+    val appStartDate = SentryNanotimeDate(1, 0)
+    val startDate = SentryNanotimeDate(2, 0)
     val appStartMetrics = AppStartMetrics.getInstance()
     val activity = mock<Activity>()
     fixture.options.dateProvider = SentryDateProvider { startDate }
@@ -2076,7 +2075,7 @@ class ActivityLifecycleIntegrationTest {
   fun `Creates activity lifecycle spans even when no app start span is available`() {
     val sut = fixture.getSut()
     fixture.options.tracesSampleRate = 1.0
-    val startDate = SentryNanotimeDate(Date(2), 0)
+    val startDate = SentryNanotimeDate(2, 0)
     val appStartMetrics = AppStartMetrics.getInstance()
     val activity = mock<Activity>()
     fixture.options.dateProvider = SentryDateProvider { startDate }
@@ -2134,8 +2133,8 @@ class ActivityLifecycleIntegrationTest {
   fun `Creates activity lifecycle spans on API lower than 29`() {
     val sut = fixture.getSut(apiVersion = Build.VERSION_CODES.P)
     fixture.options.tracesSampleRate = 1.0
-    val appStartDate = SentryNanotimeDate(Date(1), 0)
-    val startDate = SentryNanotimeDate(Date(2), 0)
+    val appStartDate = SentryNanotimeDate(1, 0)
+    val startDate = SentryNanotimeDate(2, 0)
     val appStartMetrics = AppStartMetrics.getInstance()
     val activity = mock<Activity>()
     fixture.options.dateProvider = SentryDateProvider { startDate }
@@ -2187,8 +2186,8 @@ class ActivityLifecycleIntegrationTest {
   fun `Does not add activity lifecycle spans when firstActivityCreated is true`() {
     val sut = fixture.getSut()
     fixture.options.tracesSampleRate = 1.0
-    val appStartDate = SentryNanotimeDate(Date(1), 0)
-    val startDate = SentryNanotimeDate(Date(2), 0)
+    val appStartDate = SentryNanotimeDate(1, 0)
+    val startDate = SentryNanotimeDate(2, 0)
     val appStartMetrics = AppStartMetrics.getInstance()
     val activity = mock<Activity>()
     fixture.options.dateProvider = SentryDateProvider { startDate }
@@ -2209,7 +2208,7 @@ class ActivityLifecycleIntegrationTest {
   fun `When firstActivityCreated is false and app start span has stopped, restart app start to current date`() {
     val sut = fixture.getSut()
     fixture.options.tracesSampleRate = 1.0
-    val appStartDate = SentryNanotimeDate(Date(1), 0)
+    val appStartDate = SentryNanotimeDate(1, 0)
     val appStartMetrics = AppStartMetrics.getInstance()
     val activity = mock<Activity>()
     setAppStartTime(appStartDate)
@@ -2290,7 +2289,7 @@ class ActivityLifecycleIntegrationTest {
   }
 
   private fun setAppStartTime(
-    date: SentryDate = SentryNanotimeDate(Date(1), 0),
+    date: SentryDate = SentryNanotimeDate(1, 0),
     stopDate: SentryDate? = null,
   ) {
     // set by SentryPerformanceProvider so forcing it here
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/NetworkBreadcrumbsIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/NetworkBreadcrumbsIntegrationTest.kt
index 4f6ba7fc5f0..711f5f7fe0b 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/NetworkBreadcrumbsIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/NetworkBreadcrumbsIntegrationTest.kt
@@ -5,7 +5,6 @@ import android.net.Network
 import android.net.NetworkCapabilities
 import android.os.Build
 import io.sentry.Breadcrumb
-import io.sentry.DateUtils
 import io.sentry.IScopes
 import io.sentry.ISentryExecutorService
 import io.sentry.SentryDateProvider
@@ -54,8 +53,9 @@ class NetworkBreadcrumbsIntegrationTest {
           executorService = executor
           isEnableNetworkEventBreadcrumbs = enableNetworkEventBreadcrumbs
           dateProvider = SentryDateProvider {
-            val nowNanos = TimeUnit.MILLISECONDS.toNanos(nowMs ?: System.currentTimeMillis())
-            SentryNanotimeDate(DateUtils.nanosToDate(nowNanos), nowNanos)
+            val nowMillis = nowMs ?: System.currentTimeMillis()
+            val nowNanos = TimeUnit.MILLISECONDS.toNanos(nowMillis)
+            SentryNanotimeDate(nowMillis, nowNanos)
           }
         }
       return NetworkBreadcrumbsIntegration(context, buildInfo)
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SpanFrameMetricsCollectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SpanFrameMetricsCollectorTest.kt
index e5d7349d37c..2b6f19a8d31 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SpanFrameMetricsCollectorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SpanFrameMetricsCollectorTest.kt
@@ -8,7 +8,6 @@ import io.sentry.SentryNanotimeDate
 import io.sentry.SpanContext
 import io.sentry.android.core.internal.util.SentryFrameMetricsCollector
 import io.sentry.protocol.MeasurementValue
-import java.util.Date
 import java.util.UUID
 import java.util.concurrent.TimeUnit
 import kotlin.test.Test
@@ -50,11 +49,12 @@ class SpanFrameMetricsCollectorTest {
     val span = mock<ISpan>()
     val spanContext = SpanContext("op.fake")
     whenever(span.spanContext).thenReturn(spanContext)
-    whenever(span.startDate).thenReturn(SentryNanotimeDate(Date(), startTimeStampNanos))
+    whenever(span.startDate)
+      .thenReturn(SentryNanotimeDate(System.currentTimeMillis(), startTimeStampNanos))
     whenever(span.finishDate)
       .thenReturn(
         if (endTimeStampNanos != null) {
-          SentryNanotimeDate(Date(), endTimeStampNanos)
+          SentryNanotimeDate(System.currentTimeMillis(), endTimeStampNanos)
         } else {
           null
         }
@@ -69,11 +69,12 @@ class SpanFrameMetricsCollectorTest {
     val span = mock<ITransaction>()
     val spanContext = SpanContext("op.fake")
     whenever(span.spanContext).thenReturn(spanContext)
-    whenever(span.startDate).thenReturn(SentryNanotimeDate(Date(), startTimeStampNanos))
+    whenever(span.startDate)
+      .thenReturn(SentryNanotimeDate(System.currentTimeMillis(), startTimeStampNanos))
     whenever(span.finishDate)
       .thenReturn(
         if (endTimeStampNanos != null) {
-          SentryNanotimeDate(Date(), endTimeStampNanos)
+          SentryNanotimeDate(System.currentTimeMillis(), endTimeStampNanos)
         } else {
           null
         }
@@ -438,8 +439,8 @@ class SpanFrameMetricsCollectorTest {
   @Test
   fun `SentryNanoDate diff does nano precision`() {
     // having this in here, as SpanFrameMetricsCollector relies on this behavior
-    val a = SentryNanotimeDate(Date(1234), 567)
-    val b = SentryNanotimeDate(Date(1234), 0)
+    val a = SentryNanotimeDate(1234, 567)
+    val b = SentryNanotimeDate(1234, 0)
 
     assertEquals(567, a.diff(b))
   }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/performance/ActivityLifecycleSpanHelperTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/performance/ActivityLifecycleSpanHelperTest.kt
index 710fc835acd..ef048978795 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/performance/ActivityLifecycleSpanHelperTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/performance/ActivityLifecycleSpanHelperTest.kt
@@ -12,7 +12,6 @@ import io.sentry.SpanDataConvention
 import io.sentry.SpanOptions
 import io.sentry.TracesSamplingDecision
 import io.sentry.TransactionContext
-import java.util.Date
 import java.util.concurrent.TimeUnit
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -31,8 +30,8 @@ class ActivityLifecycleSpanHelperTest {
     val appStartSpan: ISpan
     val scopes = mock<IScopes>()
     val options = SentryOptions()
-    val date = SentryNanotimeDate(Date(1), 1000000)
-    val endDate = SentryNanotimeDate(Date(3), 3000000)
+    val date = SentryNanotimeDate(1, 1000000)
+    val endDate = SentryNanotimeDate(3, 3000000)
 
     init {
       whenever(scopes.options).thenReturn(options)
@@ -59,7 +58,7 @@ class ActivityLifecycleSpanHelperTest {
   @Test
   fun `createAndStopOnCreateSpan creates and finishes onCreate span`() {
     val helper = fixture.getSut()
-    val date = SentryNanotimeDate(Date(1), 1)
+    val date = SentryNanotimeDate(1, 1)
     helper.setOnCreateStartTimestamp(date)
     helper.createAndStopOnCreateSpan(fixture.appStartSpan)
 
@@ -99,7 +98,7 @@ class ActivityLifecycleSpanHelperTest {
   @Test
   fun `createAndStopOnStartSpan creates and finishes onStart span`() {
     val helper = fixture.getSut()
-    val date = SentryNanotimeDate(Date(1), 1)
+    val date = SentryNanotimeDate(1, 1)
     helper.setOnStartStartTimestamp(date)
     helper.createAndStopOnStartSpan(fixture.appStartSpan)
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
index ab0013a8c75..2737785349f 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
@@ -18,7 +18,6 @@ import io.sentry.android.core.CurrentActivityHolder
 import io.sentry.android.core.SentryAndroidOptions
 import io.sentry.android.core.SentryShadowProcess
 import io.sentry.protocol.SentryId
-import java.util.Date
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
 import kotlin.test.Test
@@ -639,7 +638,7 @@ class AppStartMetricsTest {
   @Test
   fun `createProcessInitSpan creates a span`() {
     val appStartMetrics = AppStartMetrics.getInstance()
-    val startDate = SentryNanotimeDate(Date(1), 1000000)
+    val startDate = SentryNanotimeDate(1, 1000000)
     appStartMetrics.classLoadedUptimeMs = 10
     val startMillis = DateUtils.nanosToMillis(startDate.nanoTimestamp().toDouble()).toLong()
     appStartMetrics.appStartTimeSpan.setStartedAt(1)
diff --git a/sentry-apache-http-client-5/src/test/kotlin/io/sentry/transport/apache/ApacheHttpClientTransportTest.kt b/sentry-apache-http-client-5/src/test/kotlin/io/sentry/transport/apache/ApacheHttpClientTransportTest.kt
index 639dd4e0513..9f5c9b910ad 100644
--- a/sentry-apache-http-client-5/src/test/kotlin/io/sentry/transport/apache/ApacheHttpClientTransportTest.kt
+++ b/sentry-apache-http-client-5/src/test/kotlin/io/sentry/transport/apache/ApacheHttpClientTransportTest.kt
@@ -213,7 +213,7 @@ class ApacheHttpClientTransportTest {
     val now = Date(9001)
     val sut = fixture.getSut()
     fixture.options.dateProvider = mock()
-    whenever(fixture.options.dateProvider.now()).thenReturn(SentryNanotimeDate(now, 0))
+    whenever(fixture.options.dateProvider.now()).thenReturn(SentryNanotimeDate(now.time, 0))
 
     val envelope = SentryEnvelope.from(fixture.options.serializer, SentryEvent(), null)
     sut.send(envelope)
@@ -226,7 +226,7 @@ class ApacheHttpClientTransportTest {
     val now = Date(9001)
     val sut = fixture.getSut()
     fixture.options.dateProvider = mock()
-    whenever(fixture.options.dateProvider.now()).thenReturn(SentryNanotimeDate(now, 0))
+    whenever(fixture.options.dateProvider.now()).thenReturn(SentryNanotimeDate(now.time, 0))
 
     val envelope = SentryEnvelope.from(fixture.options.serializer, SentryEvent(), null)
     sut.send(envelope, Hint())
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 22f9366f738..e9083350349 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -382,7 +382,6 @@ public final class io/sentry/DataCategory : java/lang/Enum {
 }
 
 public final class io/sentry/DateUtils {
-	public static fun dateToNanos (Ljava/util/Date;)J
 	public static fun dateToSeconds (Ljava/util/Date;)D
 	public static fun doubleToBigDecimal (D)Ljava/math/BigDecimal;
 	public static fun getCurrentDateTime ()Ljava/util/Date;
@@ -3558,6 +3557,7 @@ public final class io/sentry/SentryMetricsEvents$JsonKeys {
 
 public final class io/sentry/SentryNanotimeDate : io/sentry/SentryDate {
 	public fun <init> ()V
+	public fun <init> (JJ)V
 	public fun <init> (Ljava/util/Date;J)V
 	public fun compareTo (Lio/sentry/SentryDate;)I
 	public synthetic fun compareTo (Ljava/lang/Object;)I
diff --git a/sentry/src/main/java/io/sentry/DateUtils.java b/sentry/src/main/java/io/sentry/DateUtils.java
index b86bddeaad8..e407391c394 100644
--- a/sentry/src/main/java/io/sentry/DateUtils.java
+++ b/sentry/src/main/java/io/sentry/DateUtils.java
@@ -151,17 +151,6 @@ public static double dateToSeconds(final @NotNull Date date) {
     return millisToSeconds(date.getTime());
   }
 
-  /**
-   * Convert {@link Date} to nanoseconds represented as {@link Long}.
-   *
-   * @param date - date
-   * @return nanoseconds
-   */
-  @SuppressWarnings("JavaUtilDate")
-  public static long dateToNanos(final @NotNull Date date) {
-    return millisToNanos(date.getTime());
-  }
-
   public static long secondsToNanos(final @NotNull long seconds) {
     return seconds * (1000L * 1000L * 1000L);
   }
diff --git a/sentry/src/main/java/io/sentry/SentryNanotimeDate.java b/sentry/src/main/java/io/sentry/SentryNanotimeDate.java
index 98c46ad5325..f3abf3518f7 100644
--- a/sentry/src/main/java/io/sentry/SentryNanotimeDate.java
+++ b/sentry/src/main/java/io/sentry/SentryNanotimeDate.java
@@ -1,32 +1,43 @@
 package io.sentry;
 
 import java.util.Date;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 /**
- * Uses {@link Date} in combination with System.nanoTime().
+ * Uses a unix timestamp (milliseconds since the epoch) in combination with System.nanoTime().
  *
- * <p>A single date only offers millisecond precision but diff can be calculated with up to
+ * <p>The unix timestamp only offers millisecond precision but diff can be calculated with up to
  * nanosecond precision. This increased precision can also be used to calculate a new end date for a
  * transaction where start date is sent with ms precision and end date is added to it with ns
  * precision leading to an end timestamp with ns precision that can be used to gain ns precision
  * transaction durations.
  *
  * <p>This is a workaround for older versions of Java (before 9) and Android API (lower than 26)
- * that allows for higher precision than {@link Date} alone would.
+ * that allows for higher precision than a millisecond timestamp alone would.
  */
+@ApiStatus.Internal
 public final class SentryNanotimeDate extends SentryDate {
 
-  private final @NotNull Date date;
+  private final long unixDateMillis;
   private final long nanos;
 
   public SentryNanotimeDate() {
-    this(DateUtils.getCurrentDateTime(), System.nanoTime());
+    this(System.currentTimeMillis(), System.nanoTime());
   }
 
+  /**
+   * @deprecated use {@link SentryNanotimeDate#SentryNanotimeDate(long, long)} instead.
+   */
+  @Deprecated
+  @SuppressWarnings({"InlineMeSuggester", "JavaUtilDate"})
   public SentryNanotimeDate(final @NotNull Date date, final long nanos) {
-    this.date = date;
+    this(date.getTime(), nanos);
+  }
+
+  public SentryNanotimeDate(final long unixDateMillis, final long nanos) {
+    this.unixDateMillis = unixDateMillis;
     this.nanos = nanos;
   }
 
@@ -41,7 +52,7 @@ public long diff(final @NotNull SentryDate otherDate) {
 
   @Override
   public long nanoTimestamp() {
-    return DateUtils.dateToNanos(date);
+    return DateUtils.millisToNanos(unixDateMillis);
   }
 
   @Override
@@ -63,8 +74,8 @@ public long laterDateNanosTimestampByDiff(final @Nullable SentryDate otherDate)
   public int compareTo(@NotNull SentryDate otherDate) {
     if (otherDate instanceof SentryNanotimeDate) {
       final @NotNull SentryNanotimeDate otherNanoDate = (SentryNanotimeDate) otherDate;
-      final long thisDateMillis = date.getTime();
-      final long otherDateMillis = otherNanoDate.date.getTime();
+      final long thisDateMillis = unixDateMillis;
+      final long otherDateMillis = otherNanoDate.unixDateMillis;
       if (thisDateMillis == otherDateMillis) {
         return Long.compare(nanos, otherNanoDate.nanos);
       } else {
diff --git a/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt b/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
index ceec3571ebd..f8e3a8f9f98 100644
--- a/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
+++ b/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
@@ -4,7 +4,6 @@ import io.sentry.test.getCtor
 import io.sentry.test.getProperty
 import io.sentry.test.injectForField
 import io.sentry.util.thread.ThreadChecker
-import java.util.Date
 import java.util.Timer
 import java.util.concurrent.TimeUnit
 import kotlin.test.Test
@@ -188,14 +187,8 @@ class DefaultCompositePerformanceCollectorTest {
     val mockCollector = mock<IPerformanceContinuousCollector>()
     val dates =
       listOf(
-        SentryNanotimeDate(
-          Date().apply { time = TimeUnit.SECONDS.toMillis(100) },
-          TimeUnit.SECONDS.toNanos(100),
-        ),
-        SentryNanotimeDate(
-          Date().apply { time = TimeUnit.SECONDS.toMillis(131) },
-          TimeUnit.SECONDS.toNanos(131),
-        ),
+        SentryNanotimeDate(TimeUnit.SECONDS.toMillis(100), TimeUnit.SECONDS.toNanos(100)),
+        SentryNanotimeDate(TimeUnit.SECONDS.toMillis(131), TimeUnit.SECONDS.toNanos(131)),
       )
     whenever(mockDateProvider.now()).thenReturn(dates[0], dates[0], dates[0], dates[1])
     val collector =
@@ -226,14 +219,8 @@ class DefaultCompositePerformanceCollectorTest {
     val mockDateProvider = mock<SentryDateProvider>()
     val dates =
       listOf(
-        SentryNanotimeDate(
-          Date().apply { time = TimeUnit.SECONDS.toMillis(100) },
-          TimeUnit.SECONDS.toNanos(100),
-        ),
-        SentryNanotimeDate(
-          Date().apply { time = TimeUnit.SECONDS.toMillis(130) },
-          TimeUnit.SECONDS.toNanos(130),
-        ),
+        SentryNanotimeDate(TimeUnit.SECONDS.toMillis(100), TimeUnit.SECONDS.toNanos(100)),
+        SentryNanotimeDate(TimeUnit.SECONDS.toMillis(130), TimeUnit.SECONDS.toNanos(130)),
       )
     whenever(mockDateProvider.now()).thenReturn(dates[0], dates[0], dates[0], dates[1])
     val collector = fixture.getSut { it.dateProvider = mockDateProvider }
diff --git a/sentry/src/test/java/io/sentry/SentryNanotimeDateTest.kt b/sentry/src/test/java/io/sentry/SentryNanotimeDateTest.kt
index 86464bcedba..3f7a5dca8b6 100644
--- a/sentry/src/test/java/io/sentry/SentryNanotimeDateTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryNanotimeDateTest.kt
@@ -1,20 +1,19 @@
 package io.sentry
 
-import java.util.Date
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
 class SentryNanotimeDateTest {
   @Test
   fun `doubleValue only offers ms precision`() {
-    val date = SentryNanotimeDate(Date(1672742031123), 123456789)
+    val date = SentryNanotimeDate(1672742031123, 123456789)
     assertEquals(1672742031123000000L, date.nanoTimestamp())
   }
 
   @Test
   fun `laterDateNanosByDiff offers ns precision`() {
-    val startDate = SentryNanotimeDate(Date(1672742031123), 456788)
-    val finishDate = SentryNanotimeDate(Date(1672742031123), 456789)
+    val startDate = SentryNanotimeDate(1672742031123, 456788)
+    val finishDate = SentryNanotimeDate(1672742031123, 456789)
     val dateInSeconds = startDate.laterDateNanosTimestampByDiff(finishDate)
     assertEquals(1672742031123000001L, dateInSeconds)
   }
@@ -26,7 +25,7 @@ class SentryNanotimeDateTest {
    */
   @Test
   fun `laterDateNanosByDiff with SentryLongDate gives ms precision`() {
-    val startDate = SentryNanotimeDate(Date(1672742031123), 456789)
+    val startDate = SentryNanotimeDate(1672742031123, 456789)
     val finishDate = SentryLongDate(61633553039)
     val dateInSeconds = startDate.laterDateNanosTimestampByDiff(finishDate)
     assertEquals(1672742031123000000L, dateInSeconds)
@@ -36,36 +35,36 @@ class SentryNanotimeDateTest {
 
   @Test
   fun `compareTo() with equal dates returns 0`() {
-    val date1 = SentryNanotimeDate(Date(1672742031123), 456789)
-    val date2 = SentryNanotimeDate(Date(1672742031123), 456789)
+    val date1 = SentryNanotimeDate(1672742031123, 456789)
+    val date2 = SentryNanotimeDate(1672742031123, 456789)
     assertEquals(0, date1.compareTo(date2))
   }
 
   @Test
   fun `compareTo() returns -1 for earlier ns`() {
-    val date1 = SentryNanotimeDate(Date(1672742031123), 456788)
-    val date2 = SentryNanotimeDate(Date(1672742031123), 456789)
+    val date1 = SentryNanotimeDate(1672742031123, 456788)
+    val date2 = SentryNanotimeDate(1672742031123, 456789)
     assertEquals(-1, date1.compareTo(date2))
   }
 
   @Test
   fun `compareTo() returns 1 for later ns`() {
-    val date1 = SentryNanotimeDate(Date(1672742031123), 456789)
-    val date2 = SentryNanotimeDate(Date(1672742031123), 456788)
+    val date1 = SentryNanotimeDate(1672742031123, 456789)
+    val date2 = SentryNanotimeDate(1672742031123, 456788)
     assertEquals(1, date1.compareTo(date2))
   }
 
   @Test
   fun `compareTo() returns -1 for earlier date`() {
-    val date1 = SentryNanotimeDate(Date(1672742030123), 456789)
-    val date2 = SentryNanotimeDate(Date(1672742031123), 456789)
+    val date1 = SentryNanotimeDate(1672742030123, 456789)
+    val date2 = SentryNanotimeDate(1672742031123, 456789)
     assertEquals(-1, date1.compareTo(date2))
   }
 
   @Test
   fun `compareTo() returns 1 for later date`() {
-    val date1 = SentryNanotimeDate(Date(1672742031123), 456789)
-    val date2 = SentryNanotimeDate(Date(1672742030123), 456789)
+    val date1 = SentryNanotimeDate(1672742031123, 456789)
+    val date2 = SentryNanotimeDate(1672742030123, 456789)
     assertEquals(1, date1.compareTo(date2))
   }
 }
diff --git a/sentry/src/test/java/io/sentry/SentryTracerTest.kt b/sentry/src/test/java/io/sentry/SentryTracerTest.kt
index 1ccbcf2f318..3b808dd2220 100644
--- a/sentry/src/test/java/io/sentry/SentryTracerTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTracerTest.kt
@@ -8,7 +8,6 @@ import io.sentry.test.getProperty
 import io.sentry.util.thread.IThreadChecker
 import java.time.LocalDateTime
 import java.time.ZoneOffset
-import java.util.Date
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -184,7 +183,7 @@ class SentryTracerTest {
     val tracer = fixture.getSut()
     val date =
       SentryNanotimeDate(
-        Date.from(LocalDateTime.of(2022, 12, 24, 23, 59, 58, 0).toInstant(ZoneOffset.UTC)),
+        LocalDateTime.of(2022, 12, 24, 23, 59, 58, 0).toInstant(ZoneOffset.UTC).toEpochMilli(),
         0,
       )
     tracer.finish(SpanStatus.ABORTED, date)
@@ -643,7 +642,7 @@ class SentryTracerTest {
 
   @Test
   fun `when startTimestamp is given, use it as startTimestamp`() {
-    val date = SentryNanotimeDate(Date(0), 0)
+    val date = SentryNanotimeDate(0, 0)
     val transaction = fixture.getSut(startTimestamp = date)
 
     assertSame(date, transaction.startDate)
diff --git a/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportTest.kt b/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportTest.kt
index 70092ffa7ba..6f711cfedbf 100644
--- a/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportTest.kt
+++ b/sentry/src/test/java/io/sentry/transport/AsyncHttpTransportTest.kt
@@ -367,7 +367,7 @@ class AsyncHttpTransportTest {
     // given
     val now = Date(9001)
     fixture.sentryOptions.dateProvider = mock()
-    whenever(fixture.sentryOptions.dateProvider.now()).thenReturn(SentryNanotimeDate(now, 0))
+    whenever(fixture.sentryOptions.dateProvider.now()).thenReturn(SentryNanotimeDate(now.time, 0))
 
     val envelope = SentryEnvelope.from(fixture.sentryOptions.serializer, createSession(), null)
     whenever(fixture.transportGate.isConnected).thenReturn(true)
@@ -387,7 +387,7 @@ class AsyncHttpTransportTest {
     // given
     val now = Date(9001)
     fixture.sentryOptions.dateProvider = mock()
-    whenever(fixture.sentryOptions.dateProvider.now()).thenReturn(SentryNanotimeDate(now, 0))
+    whenever(fixture.sentryOptions.dateProvider.now()).thenReturn(SentryNanotimeDate(now.time, 0))
 
     val envelope = SentryEnvelope.from(fixture.sentryOptions.serializer, createSession(), null)
     whenever(fixture.transportGate.isConnected).thenReturn(true)

From f944a75eb71cc82131a624d4fd91edeaa42bab7b Mon Sep 17 00:00:00 2001
From: runningcode <332597+runningcode@users.noreply.github.com>
Date: Wed, 17 Jun 2026 13:53:20 +0000
Subject: [PATCH 210/391] release: 8.44.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0de5fc72452..4cf56d17cee 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.44.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 35641a00053..19127ac9832 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.43.2
+versionName=8.44.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 5dc86e8f233e15687c3a51ce4d05226196638f14 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Wed, 17 Jun 2026 17:05:40 +0200
Subject: [PATCH 211/391] chore(android-sqlite): Remove calls to deprecated
 SentryNanotimeDate constructor (#5562)

---
 .../java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt     | 3 +--
 .../sentry/sqlite/ComputeNanoStartTimestampForChildTest.kt | 3 +--
 .../java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt | 7 +++----
 3 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
index 5099f38f691..f0998dfdc23 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
@@ -10,7 +10,6 @@ import io.sentry.SentryNanotimeDate
 import io.sentry.SentryStackTraceFactory
 import io.sentry.SpanDataConvention
 import io.sentry.SpanStatus
-import java.util.Date
 
 private const val SQLITE_TRACE_ORIGIN = "auto.db.sqlite"
 
@@ -18,7 +17,7 @@ private const val SQLITE_TRACE_ORIGIN = "auto.db.sqlite"
  * Sentinel for extracting a [SentryNanotimeDate]'s underlying [System.nanoTime] value via
  * [SentryDate.diff].
  */
-private val EMPTY_NANO_TIME = SentryNanotimeDate(Date(0), 0L)
+private val EMPTY_NANO_TIME = SentryNanotimeDate(0, 0L)
 
 /** Span instrumentation for [SentrySQLiteDriver]. */
 internal class SQLiteSpanInstrumentation(
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/ComputeNanoStartTimestampForChildTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/ComputeNanoStartTimestampForChildTest.kt
index 92a98b6e56d..13ae1389b77 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/ComputeNanoStartTimestampForChildTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/ComputeNanoStartTimestampForChildTest.kt
@@ -4,7 +4,6 @@ import io.sentry.DateUtils
 import io.sentry.ISpan
 import io.sentry.SentryLongDate
 import io.sentry.SentryNanotimeDate
-import java.util.Date
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNull
@@ -86,7 +85,7 @@ class ComputeNanoStartTimestampForChildTest {
   }
 
   private fun spanWithNanotimeStart(wallClockMillis: Long, parentMonotonicNanos: Long): ISpan {
-    val startDate = SentryNanotimeDate(Date(wallClockMillis), parentMonotonicNanos)
+    val startDate = SentryNanotimeDate(wallClockMillis, parentMonotonicNanos)
     val span = mock<ISpan>()
     whenever(span.startDate).thenReturn(startDate)
     return span
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
index a38be242ec5..74bd1c7f882 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
@@ -11,7 +11,6 @@ import io.sentry.SpanDataConvention
 import io.sentry.SpanStatus
 import io.sentry.TransactionContext
 import io.sentry.util.thread.IThreadChecker
-import java.util.Date
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -51,7 +50,7 @@ class SQLiteSpanInstrumentationTest {
     // Only the parent date is queued. If startTimestamp() were to call dateProvider.now(),
     // the queue would underflow and the test would fail loudly — this is what verifies the
     // optimization is in effect.
-    val parentDate = SentryNanotimeDate(Date(1_000_000L), 100_000_000L)
+    val parentDate = SentryNanotimeDate(1_000_000L, 100_000_000L)
     val sut = setUpWithNanotimeDates(parentDate)
 
     val start = sut.startTimestamp()
@@ -71,7 +70,7 @@ class SQLiteSpanInstrumentationTest {
 
   @Test
   fun `startTimestamp falls back to date provider when parent does not use SentryNanotimeDate`() {
-    val providerDate = SentryNanotimeDate(Date(2_000_000L), 200_000_000L)
+    val providerDate = SentryNanotimeDate(2_000_000L, 200_000_000L)
     val parentSpan = mock<ISpan>()
     whenever(parentSpan.startDate).thenReturn(SentryLongDate(1_000_000_000_000_000L))
     val options =
@@ -89,7 +88,7 @@ class SQLiteSpanInstrumentationTest {
 
   @Test
   fun `startTimestamp falls back to date provider when no transaction is active`() {
-    val providerDate = SentryNanotimeDate(Date(2_000_000L), 200_000_000L)
+    val providerDate = SentryNanotimeDate(2_000_000L, 200_000_000L)
     val options =
       SentryOptions().apply {
         dsn = "https://key@sentry.io/proj"

From 10a0bc2fdb190596413bf6d105438474c6663445 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Thu, 18 Jun 2026 11:04:24 +0200
Subject: [PATCH 212/391] feat(android-sqlite): Make SentrySQLiteDriver
 experimental (JAVA-275) (#5563)

Makes SentrySQLiteDriver public + experimental during development. In particular, lets us access the driver via the Sentry Android sample app.
---
 CHANGELOG.md                                         |  8 ++++++++
 sentry-android-sqlite/api/sentry-android-sqlite.api  | 12 ++++++++++++
 sentry-android-sqlite/build.gradle.kts               |  5 +++++
 .../main/java/io/sentry/sqlite/SentrySQLiteDriver.kt | 10 +++++++---
 4 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4cf56d17cee..8428f033b78 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+### Features
+
+- Add experimental `SentrySQLiteDriver` to `sentry-android-sqlite` for instrumenting `androidx.sqlite.SQLiteDriver` ([#5563](https://github.com/getsentry/sentry-java/pull/5563))
+  - To use it, pass `SQLiteDriver` to `SentrySQLiteDriver.create(...)`
+  - Requires `androidx.sqlite:sqlite` (2.5.0+) on runtime classpath (typically provided by Room or SQLDelight)
+
 ## 8.44.0
 
 ### Features
diff --git a/sentry-android-sqlite/api/sentry-android-sqlite.api b/sentry-android-sqlite/api/sentry-android-sqlite.api
index c8780f1338d..7b9f633b46a 100644
--- a/sentry-android-sqlite/api/sentry-android-sqlite.api
+++ b/sentry-android-sqlite/api/sentry-android-sqlite.api
@@ -21,3 +21,15 @@ public final class io/sentry/android/sqlite/SentrySupportSQLiteOpenHelper$Compan
 	public final fun create (Landroidx/sqlite/db/SupportSQLiteOpenHelper;)Landroidx/sqlite/db/SupportSQLiteOpenHelper;
 }
 
+public final class io/sentry/sqlite/SentrySQLiteDriver : androidx/sqlite/SQLiteDriver {
+	public static final field Companion Lio/sentry/sqlite/SentrySQLiteDriver$Companion;
+	public synthetic fun <init> (Landroidx/sqlite/SQLiteDriver;Lkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public static final fun create (Landroidx/sqlite/SQLiteDriver;)Landroidx/sqlite/SQLiteDriver;
+	public fun hasConnectionPool ()Z
+	public fun open (Ljava/lang/String;)Landroidx/sqlite/SQLiteConnection;
+}
+
+public final class io/sentry/sqlite/SentrySQLiteDriver$Companion {
+	public final fun create (Landroidx/sqlite/SQLiteDriver;)Landroidx/sqlite/SQLiteDriver;
+}
+
diff --git a/sentry-android-sqlite/build.gradle.kts b/sentry-android-sqlite/build.gradle.kts
index dd28252665e..6e0275b29b8 100644
--- a/sentry-android-sqlite/build.gradle.kts
+++ b/sentry-android-sqlite/build.gradle.kts
@@ -47,6 +47,10 @@ android {
 
   buildFeatures { buildConfig = true }
 
+  // Needed b/c Kotlin 1.4.x would otherwise pull in an older version without the annotations we
+  // want.
+  configurations.all { resolutionStrategy.force(libs.jetbrains.annotations.get()) }
+
   androidComponents.beforeVariants {
     it.enable = !Config.Android.shouldSkipDebugVariant(it.buildType)
   }
@@ -65,6 +69,7 @@ dependencies {
   api(projects.sentry)
 
   compileOnly(libs.androidx.sqlite)
+  compileOnly(libs.jetbrains.annotations)
 
   implementation(kotlin(Config.kotlinStdLib, Config.kotlinStdLibVersionAndroid))
 
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
index 9a619c418a5..e869778b811 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
@@ -5,6 +5,7 @@ import androidx.sqlite.SQLiteDriver
 import io.sentry.ScopesAdapter
 import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.SentryLevel
+import org.jetbrains.annotations.ApiStatus
 
 /**
  * Wraps a [SQLiteDriver] and automatically adds spans for each SQL statement it executes.
@@ -28,13 +29,16 @@ import io.sentry.SentryLevel
  *
  * @param delegate The [SQLiteDriver] instance to delegate calls to.
  */
-internal class SentrySQLiteDriver private constructor(private val delegate: SQLiteDriver) :
+@ApiStatus.Experimental
+public class SentrySQLiteDriver private constructor(private val delegate: SQLiteDriver) :
   SQLiteDriver {
 
   init {
     SentryIntegrationPackageStorage.getInstance().addIntegration("SQLiteDriver")
   }
 
+  @Suppress("INAPPLICABLE_JVM_NAME")
+  @get:JvmName("hasConnectionPool")
   override val hasConnectionPool: Boolean
     get() =
       try {
@@ -66,14 +70,14 @@ internal class SentrySQLiteDriver private constructor(private val delegate: SQLi
     }
   }
 
-  companion object {
+  public companion object {
 
     /**
      * Wraps the provided delegate in a [SentrySQLiteDriver]. Returns the delegate as-is if already
      * wrapped.
      */
     @JvmStatic
-    fun create(delegate: SQLiteDriver): SQLiteDriver =
+    public fun create(delegate: SQLiteDriver): SQLiteDriver =
       delegate as? SentrySQLiteDriver ?: SentrySQLiteDriver(delegate)
   }
 }

From f6192aacb057496dd89e4fdb72ed2741e50e03ee Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Thu, 18 Jun 2026 11:38:27 +0200
Subject: [PATCH 213/391] chore(android-sqlite): Add SQLite samples to
 sentry-samples-android (#5504)

Adds our SQLite integrations to sentry-android-samples (`SentrySQLiteDriver` and `SentrySupportOpenSQLiteHelper`).

The entry point is `SQLiteActivity`. Example SQL statements are identical across integrations so we can observe similarities / differences in how they handle spans. Users can exercise the integrations directly or via Room or SQLDelight.
---
 gradle/libs.versions.toml                     |  31 +-
 .../sentry-samples-android/README.md          |   2 +-
 .../sentry-samples-android/build.gradle.kts   |  42 +-
 .../src/main/AndroidManifest.xml              |   8 +
 .../io/sentry/samples/android/MainActivity.kt |  14 +
 .../sentry/samples/android/MyApplication.java |   3 +
 .../samples/android/sqlite/DisplayInfo.kt     | 106 +++
 .../sentry/samples/android/sqlite/Room2Dao.kt |  42 ++
 .../sentry/samples/android/sqlite/Room3Dao.kt |  42 ++
 .../samples/android/sqlite/SQLiteActivity.kt  | 621 ++++++++++++++++++
 .../samples/android/sqlite/SampleDatabases.kt | 222 +++++++
 .../io/sentry/samples/android/sqlite/Song.sq  |  17 +
 .../samples/android/sqlite/SqlStatements.kt   | 226 +++++++
 .../samples/android/sqlite/UiLoadActivity.kt  |  69 ++
 .../samples/android/sqlite/UiLoadScreen.kt    | 110 ++++
 15 files changed, 1542 insertions(+), 13 deletions(-)
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/DisplayInfo.kt
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Room2Dao.kt
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Room3Dao.kt
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Song.sq
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SqlStatements.kt
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadActivity.kt
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadScreen.kt

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c16a87ad9b6..91a7669194f 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -5,15 +5,18 @@ androidxNavigation = "2.4.2"
 androidxTestCore = "1.7.0"
 androidxCompose = "1.6.3"
 asyncProfiler = "4.4"
+camerax = "1.4.0"
 composeCompiler = "1.5.14"
 coroutines = "1.6.1"
 espresso = "3.7.0"
 feign = "11.6"
+gummyBears = "0.12.0"
 jackson = "2.18.3"
 jetbrainsCompose = "1.6.11"
 kotlin = "2.2.0"
 kotlinSpring7 = "2.2.0"
 kotlin-compatible-version = "1.9"
+ksp = "2.3.9"
 ktorClient = "3.0.0"
 logback = "1.2.9"
 log4j2 = "2.20.0"
@@ -21,6 +24,7 @@ nopen = "1.0.1"
 # see https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-compatibility-and-versioning.html#kotlin-compatibility
 # see https://developer.android.com/jetpack/androidx/releases/compose-kotlin
 okhttp = "4.9.2"
+openfeature = "1.18.2"
 otel = "1.60.1"
 otelInstrumentation = "2.26.0"
 otelInstrumentationAlpha = "2.26.0-alpha"
@@ -28,19 +32,22 @@ otelInstrumentationAlpha = "2.26.0-alpha"
 otelSemanticConventions = "1.40.0"
 otelSemanticConventionsAlpha = "1.40.0-alpha"
 retrofit = "2.9.0"
+room2 = "2.8.4"
+room3 = "3.0.0-alpha06"
 sagp = "6.10.0"
+sqlite = "2.6.2"
+sqliteAlpha = "2.7.0-alpha06" # Required by Room3 3.0.0-alpha*
 slf4j = "1.7.30"
+spotless = "8.4.0"
 springboot2 = "2.7.18"
 springboot3 = "3.5.0"
 springboot4 = "4.0.0"
+sqldelight = "2.3.2"
+
 # Android
 targetSdk = "36"
 compileSdk = "36"
 minSdk = "21"
-spotless = "8.4.0"
-gummyBears = "0.12.0"
-camerax = "1.4.0"
-openfeature = "1.18.2"
 
 [plugins]
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
@@ -50,6 +57,7 @@ kotlin-jvm-spring7 = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlinSpr
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
 buildconfig = { id = "com.github.gmazzo.buildconfig", version = "5.6.5" }
 dokka = { id = "org.jetbrains.dokka", version = "2.0.0" }
 dokka-javadoc = { id = "org.jetbrains.dokka-javadoc", version = "2.0.0" }
@@ -62,6 +70,7 @@ vanniktech-maven-publish = { id = "com.vanniktech.maven.publish", version = "0.3
 springboot3 = { id = "org.springframework.boot", version.ref = "springboot3" }
 springboot4 = { id = "org.springframework.boot", version.ref = "springboot4" }
 spring-dependency-management = { id = "io.spring.dependency-management", version = "1.1.7" }
+sqldelight = { id = "app.cash.sqldelight", version.ref = "sqldelight" }
 gretty = { id = "org.gretty", version = "4.0.0" }
 animalsniffer = { id = "ru.vyarus.animalsniffer", version = "2.0.1" }
 sentry = { id = "io.sentry.android.gradle", version.ref = "sagp"}
@@ -92,7 +101,14 @@ androidx-lifecycle-common-java8 = { module = "androidx.lifecycle:lifecycle-commo
 androidx-lifecycle-process = { module = "androidx.lifecycle:lifecycle-process", version.ref = "androidxLifecycle" }
 androidx-navigation-runtime = { module = "androidx.navigation:navigation-runtime", version.ref = "androidxNavigation" }
 androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "androidxNavigation" }
-androidx-sqlite = { module = "androidx.sqlite:sqlite", version = "2.6.2" }
+androidx-room-compiler = { module = "androidx.room:room-compiler", version.ref = "room2" }
+androidx-room-ktx = { module = "androidx.room:room-ktx", version.ref = "room2" }
+androidx-room-runtime = { module = "androidx.room:room-runtime", version.ref = "room2" }
+androidx-room3-compiler = { module = "androidx.room3:room3-compiler", version.ref = "room3" }
+androidx-room3-runtime = { module = "androidx.room3:room3-runtime", version.ref = "room3" }
+androidx-sqlite = { module = "androidx.sqlite:sqlite", version.ref = "sqlite" }
+androidx-sqlite-bundled = { module = "androidx.sqlite:sqlite-bundled", version.ref = "sqliteAlpha" }
+androidx-sqlite-framework = { module = "androidx.sqlite:sqlite-framework", version.ref = "sqliteAlpha" }
 androidx-recyclerview = { module = "androidx.recyclerview:recyclerview", version = "1.2.1" }
 androidx-browser = { module = "androidx.browser:browser", version = "1.8.0" }
 async-profiler = { module = "tools.profiler:async-profiler", version.ref = "asyncProfiler" }
@@ -205,6 +221,7 @@ springboot4-starter-jdbc = { module = "org.springframework.boot:spring-boot-star
 springboot4-starter-actuator = { module = "org.springframework.boot:spring-boot-starter-actuator", version.ref = "springboot4" }
 springboot4-starter-cache = { module = "org.springframework.boot:spring-boot-starter-cache", version.ref = "springboot4" }
 springboot4-starter-kafka = { module = "org.springframework.boot:spring-boot-starter-kafka", version.ref = "springboot4" }
+sqldelight-android-driver = { module = "app.cash.sqldelight:android-driver", version.ref = "sqldelight" }
 timber = { module = "com.jakewharton.timber:timber", version = "4.7.1" }
 
 # Animalsniffer signature
@@ -248,3 +265,7 @@ msgpack = { module = "org.msgpack:msgpack-core", version = "0.9.8" }
 okhttp-mockwebserver = { module = "com.squareup.okhttp3:mockwebserver", version.ref = "okhttp" }
 okio = { module = "com.squareup.okio:okio", version = "1.13.0" }
 roboelectric = { module = "org.robolectric:robolectric", version = "4.15" }
+
+[bundles]
+androidx-room2 = ["androidx-room-runtime", "androidx-room-ktx"]
+androidx-sqlite-drivers = ["androidx-sqlite-bundled", "androidx-sqlite-framework"]
diff --git a/sentry-samples/sentry-samples-android/README.md b/sentry-samples/sentry-samples-android/README.md
index f5c8caf8685..99d0edcd1c3 100644
--- a/sentry-samples/sentry-samples-android/README.md
+++ b/sentry-samples/sentry-samples-android/README.md
@@ -1,7 +1,7 @@
 # Sentry Sample Android App
 
 Sample application demonstrating how to use the Sentry Android SDK, including core functionality (error reporting, tracing, session replay,
-profiling) and integrations (Compose, OkHttp, etc.).
+profiling) and integrations (Compose, OkHttp, SQLite, etc.).
 
 ## How to run it?
 
diff --git a/sentry-samples/sentry-samples-android/build.gradle.kts b/sentry-samples/sentry-samples-android/build.gradle.kts
index e19c02700fb..74e3c3a57b8 100644
--- a/sentry-samples/sentry-samples-android/build.gradle.kts
+++ b/sentry-samples/sentry-samples-android/build.gradle.kts
@@ -9,7 +9,9 @@ plugins {
   id("com.android.application")
   alias(libs.plugins.kotlin.android)
   alias(libs.plugins.kotlin.compose)
+  alias(libs.plugins.ksp)
   alias(libs.plugins.sentry) apply false
+  alias(libs.plugins.sqldelight)
 }
 
 if (providers.gradleProperty("useSagp").isPresent) {
@@ -26,9 +28,9 @@ plugins.withId("io.sentry.android.gradle") {
     tracingInstrumentation {
       features.set(
         setOf(
+          // FILE_IO is disabled for non-SAGP builds.
           InstrumentationFeature.COMPOSE,
           InstrumentationFeature.DATABASE,
-          InstrumentationFeature.FILE_IO,
           InstrumentationFeature.OKHTTP,
         )
       )
@@ -44,7 +46,8 @@ android {
 
   defaultConfig {
     applicationId = "io.sentry.samples.android"
-    minSdk = libs.versions.minSdk.get().toInt()
+    // androidx.sqlite 2.6+ require minSdk 23; the Sentry SDK still supports 21.
+    minSdk = 23
     targetSdk = libs.versions.targetSdk.get().toInt()
     versionCode = 2
     versionName = project.version.toString()
@@ -119,7 +122,13 @@ android {
     }
   }
 
-  kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8 }
+  // Java 11 b/c androidx.room3 requires it.
+  compileOptions {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+  }
+
+  kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11 }
 
   androidComponents.beforeVariants {
     it.enable = !Config.Android.shouldSkipDebugVariant(it.buildType)
@@ -145,6 +154,17 @@ android {
   @Suppress("UnstableApiUsage") packagingOptions { jniLibs { useLegacyPackaging = true } }
 }
 
+sqldelight {
+  databases {
+    create("SampleSQLDelightDatabase") {
+      packageName.set("io.sentry.samples.android.sqlite")
+      // Keep .sq files next to the hand-written Kotlin (src/main/java/.../sqlite) instead of the
+      // default src/main/sqldelight source root.
+      srcDirs("src/main/java")
+    }
+  }
+}
+
 dependencies {
   implementation(
     kotlin(Config.kotlinStdLib, org.jetbrains.kotlin.config.KotlinCompilerVersion.VERSION)
@@ -152,6 +172,7 @@ dependencies {
 
   implementation(projects.sentryAndroid)
   implementation(projects.sentryAndroidFragment)
+  implementation(projects.sentryAndroidSqlite)
   implementation(projects.sentryAndroidTimber)
   implementation(projects.sentryCompose)
   implementation(projects.sentryKotlinExtensions)
@@ -177,17 +198,24 @@ dependencies {
   implementation(libs.androidx.navigation.compose)
   implementation(libs.androidx.recyclerview)
   implementation(libs.androidx.browser)
+  implementation(libs.androidx.room3.runtime)
+  implementation(libs.bundles.androidx.room2)
+  implementation(libs.bundles.androidx.sqlite.drivers)
+  implementation(libs.camerax.camera2)
+  implementation(libs.camerax.core)
+  implementation(libs.camerax.lifecycle)
+  implementation(libs.camerax.view)
   implementation(libs.coil.compose)
   implementation(libs.kotlinx.coroutines.android)
   implementation(libs.lottie.compose)
   implementation(libs.retrofit)
   implementation(libs.retrofit.gson)
   implementation(libs.sentry.native.ndk)
+  implementation(libs.sqldelight.android.driver)
   implementation(libs.timber)
-  implementation(libs.camerax.core)
-  implementation(libs.camerax.camera2)
-  implementation(libs.camerax.lifecycle)
-  implementation(libs.camerax.view)
+
+  ksp(libs.androidx.room.compiler)
+  ksp(libs.androidx.room3.compiler)
 
   debugImplementation(projects.sentryAndroidDistribution)
   debugImplementation(libs.leakcanary)
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 14c8b595fd3..1150dd5ef2e 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -101,6 +101,14 @@
       android:name=".TriggerHttpRequestActivity"
       android:exported="false" />
 
+    <activity
+      android:name=".sqlite.SQLiteActivity"
+      android:exported="false" />
+
+    <activity
+      android:name=".sqlite.UiLoadActivity"
+      android:exported="false" />
+
     <!--    NOTE: Replace the test DSN below with YOUR OWN DSN to see the events from this app in your Sentry project/dashboard-->
     <meta-data
       android:name="io.sentry.dsn"
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
index 86f1aace82e..b87e7a3190c 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
@@ -473,6 +473,20 @@ fun TracingScreen() {
         }
       }
     }
+    item {
+      SentryTraced("open_sqlite") {
+        OutlinedButton(
+          onClick = {
+            activity.startActivity(
+              Intent(activity, io.sentry.samples.android.sqlite.SQLiteActivity::class.java)
+            )
+          },
+          modifier = Modifier,
+        ) {
+          Text("Open SQLite Activity", maxLines = 2, overflow = TextOverflow.Ellipsis)
+        }
+      }
+    }
   }
 }
 
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java
index f074901f4f0..6df8ede588e 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java
@@ -3,6 +3,7 @@
 import android.app.Application;
 import android.os.StrictMode;
 import io.sentry.Sentry;
+import io.sentry.samples.android.sqlite.SampleDatabases;
 
 /** Apps. main Application. */
 public class MyApplication extends Application {
@@ -18,6 +19,8 @@ public void onCreate() {
     strictMode();
     super.onCreate();
 
+    SampleDatabases.INSTANCE.warmUp(this);
+
     // Example how to initialize the SDK manually which allows access to SentryOptions callbacks.
     // Make sure you disable the auto init via manifest meta-data: io.sentry.auto-init=false
     // SentryAndroid.init(
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/DisplayInfo.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/DisplayInfo.kt
new file mode 100644
index 00000000000..14582fe305e
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/DisplayInfo.kt
@@ -0,0 +1,106 @@
+package io.sentry.samples.android.sqlite
+
+/**
+ * Display text for each "SQL run" summary shown in the [SQLiteActivity] screen UI. Documentation
+ * only / never executed. The real statements live in [SqlStatements].
+ */
+internal data class DisplayInfo(val sql: String, val sqlHeavy: String = sql)
+
+internal val DRIVER_DIRECT =
+  DisplayInfo(
+    sql =
+      """
+      CREATE TABLE IF NOT EXISTS song(…)
+      INSERT INTO song(title, artist) VALUES (?, ?)
+      SELECT count(*) FROM song
+      """
+        .trimIndent(),
+    sqlHeavy =
+      """
+      CREATE TABLE IF NOT EXISTS song(…)
+      INSERT INTO song(title, artist) VALUES (?, ?)
+      INSERT INTO song(title, artist) VALUES (?, ?), (?, ?), … (?, ?)
+      SELECT id, title, artist FROM song
+      SELECT count(*) FROM song
+      -- then, per row: appWork() = 500x SHA-256, in the app (not in any span)
+      """
+        .trimIndent(),
+  )
+
+internal val DRIVER_ROOM2 =
+  DisplayInfo(
+    sql =
+      """
+      INSERT OR ABORT INTO `song` (…) VALUES (nullif(?, 0), ?, ?)
+      SELECT count(*) FROM song
+      """
+        .trimIndent(),
+    sqlHeavy =
+      """
+      INSERT OR ABORT INTO `song` (…) VALUES (nullif(?, 0), ?, ?)
+      SELECT * FROM song
+      SELECT count(*) FROM song
+      -- then, per row: appWork() = 500x SHA-256, outside the step()-timed spans
+      """
+        .trimIndent(),
+  )
+
+// Room 3 issues the same statements as Room 2 (see SqlStatements.driverWithRoom3).
+internal val DRIVER_ROOM3 = DRIVER_ROOM2
+
+internal val OPENHELPER_DIRECT =
+  DisplayInfo(
+    sql =
+      """
+      CREATE TABLE IF NOT EXISTS song(…)
+      INSERT INTO song(title, artist) VALUES (?, ?)
+      SELECT count(*) FROM song
+      """
+        .trimIndent(),
+    sqlHeavy =
+      """
+      CREATE TABLE IF NOT EXISTS song(…)
+      INSERT INTO song(title, artist) VALUES (?, ?)
+      INSERT INTO song(title, artist) VALUES (?, ?), (?, ?), … (?, ?)
+      SELECT id, title, artist FROM song
+      SELECT count(*) FROM song
+      -- then, per row: appWork() = 500x SHA-256, in the app
+      """
+        .trimIndent(),
+  )
+
+internal val OPENHELPER_ROOM =
+  DisplayInfo(
+    sql =
+      """
+      INSERT OR ABORT INTO `song` (…) VALUES (nullif(?, 0), ?, ?)
+      SELECT count(*) FROM song
+      """
+        .trimIndent(),
+    sqlHeavy =
+      """
+      INSERT OR ABORT INTO `song` (…) VALUES (nullif(?, 0), ?, ?)
+      SELECT * FROM song
+      SELECT count(*) FROM song
+      -- then, per row: appWork() = 500x SHA-256, in the app
+      """
+        .trimIndent(),
+  )
+
+internal val OPENHELPER_SQLDELIGHT =
+  DisplayInfo(
+    sql =
+      """
+      INSERT INTO song(title, artist) VALUES (?, ?)
+      SELECT count(*) FROM song
+      """
+        .trimIndent(),
+    sqlHeavy =
+      """
+      INSERT INTO song(title, artist) VALUES (?, ?)
+      SELECT * FROM song
+      SELECT count(*) FROM song
+      -- then, per row: appWork() = 500x SHA-256, in the app
+      """
+        .trimIndent(),
+  )
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Room2Dao.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Room2Dao.kt
new file mode 100644
index 00000000000..31814c750bc
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Room2Dao.kt
@@ -0,0 +1,42 @@
+package io.sentry.samples.android.sqlite
+
+import androidx.room.Dao
+import androidx.room.Database
+import androidx.room.Entity
+import androidx.room.Insert
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.RoomDatabase
+
+@Entity(tableName = "song")
+data class SongEntity(
+  @PrimaryKey(autoGenerate = true) val id: Long = 0,
+  val title: String,
+  val artist: String,
+)
+
+@Dao
+interface SongDao {
+
+  @Insert suspend fun insert(song: SongEntity)
+
+  /** Batch insert: Room runs all rows in a single transaction, reusing one compiled statement. */
+  @Insert suspend fun insertAll(songs: List<SongEntity>)
+
+  @Query("SELECT * FROM song") suspend fun getAll(): List<SongEntity>
+
+  @Query("SELECT count(*) FROM song") suspend fun count(): Int
+
+  /**
+   * No-op write (matches no rows) used at warm-up to open Room's writer connection up front. A read
+   * like [count] only opens a reader, so without this the first INSERT would (noisily) open and
+   * bootstrap the writer connection inside a demo transaction.
+   */
+  @Query("DELETE FROM song WHERE id < 0") suspend fun primeWriter()
+}
+
+@Database(entities = [SongEntity::class], version = 1, exportSchema = false)
+abstract class SampleRoom2Database : RoomDatabase() {
+
+  abstract fun songDao(): SongDao
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Room3Dao.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Room3Dao.kt
new file mode 100644
index 00000000000..145e12d3897
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Room3Dao.kt
@@ -0,0 +1,42 @@
+package io.sentry.samples.android.sqlite
+
+import androidx.room3.Dao
+import androidx.room3.Database
+import androidx.room3.Entity
+import androidx.room3.Insert
+import androidx.room3.PrimaryKey
+import androidx.room3.Query
+import androidx.room3.RoomDatabase
+
+@Entity(tableName = "song")
+data class SongEntity3(
+  @PrimaryKey(autoGenerate = true) val id: Long = 0,
+  val title: String,
+  val artist: String,
+)
+
+@Dao
+interface SongDao3 {
+
+  @Insert suspend fun insert(song: SongEntity3)
+
+  /** Batch insert: Room runs all rows in a single transaction, reusing one compiled statement. */
+  @Insert suspend fun insertAll(songs: List<SongEntity3>)
+
+  @Query("SELECT * FROM song") suspend fun getAll(): List<SongEntity3>
+
+  @Query("SELECT count(*) FROM song") suspend fun count(): Int
+
+  /**
+   * No-op write (matches no rows) used at warm-up to open Room's writer connection up front. A read
+   * like [count] only opens a reader, so without this the first INSERT would (noisily) open and
+   * bootstrap the writer connection inside a demo transaction.
+   */
+  @Query("DELETE FROM song WHERE id < 0") suspend fun primeWriter()
+}
+
+@Database(entities = [SongEntity3::class], version = 1, exportSchema = false)
+abstract class SampleRoom3Database : RoomDatabase() {
+
+  abstract fun songDao(): SongDao3
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt
new file mode 100644
index 00000000000..1ff6828a757
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt
@@ -0,0 +1,621 @@
+package io.sentry.samples.android.sqlite
+
+import android.os.Bundle
+import android.widget.Toast
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.keyframes
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.outlined.HelpOutline
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.OutlinedTextFieldDefaults
+import androidx.compose.material3.PlainTooltip
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Switch
+import androidx.compose.material3.SwitchColors
+import androidx.compose.material3.SwitchDefaults
+import androidx.compose.material3.Text
+import androidx.compose.material3.TooltipBox
+import androidx.compose.material3.TooltipDefaults
+import androidx.compose.material3.rememberTooltipState
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.scale
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.lerp
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.lifecycleScope
+import io.sentry.Sentry
+import io.sentry.SpanId
+import io.sentry.SpanStatus
+import io.sentry.TransactionContext
+import io.sentry.TransactionOptions
+import io.sentry.protocol.SentryId
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+private val SentryPink = Color(0xFFC85B9C)
+private val SentryPurple = Color(0xFF7B52FB)
+private val SentryRed = Color(0xFFF55459)
+
+/** Intro text, surfaced via the "?" tooltip next to the "Run it" header. */
+private const val INSTRUCTIONS =
+  "Tap a button to execute a SQL statement in its own transaction; long press to run it in a ui.load transaction."
+
+/** Start state of the "SQL run" box. */
+private const val SQL_DETAIL_HINT = "Tap a button above to see the SQL it runs…"
+
+private val TOGGLE_SECTION_GAP = 24.dp
+
+private val CONTROL_SECTION_GAP = TOGGLE_SECTION_GAP * 2
+
+private val SECTION_HEADER_HEIGHT = 28.dp
+
+/** Which sentry-android-sqlite integration the demo buttons currently target. */
+private enum class Integration(val color: Color, val apiName: String) {
+  DRIVER(SentryPurple, "SQLiteDriver"),
+  OPEN_HELPER(SentryPink, "SupportSQLiteOpenHelper"),
+}
+
+/**
+ * How one demo button behaves for a given integration: which [SqlStatements] work it runs ([demo]),
+ * the name/op of the manual transaction a tap wraps it in, and the SQL summary shown in the detail
+ * panel ([displayInfo]).
+ */
+private class DemoVariant(
+  val demo: SqlDemo,
+  val transactionName: String,
+  val op: String,
+  val displayInfo: DisplayInfo,
+)
+
+/**
+ * A single demo button in the list. [driver] / [openHelper] hold the variant for each integration;
+ * a null variant means the row doesn't apply to that integration and renders dimmed, explaining why
+ * on click (Room 3 is driver-only; SQLDelight is open-helper-only).
+ */
+private class DemoRow(val label: String, val driver: DemoVariant?, val openHelper: DemoVariant?)
+
+// The demo buttons, top to bottom, paired with each integration's variant. Pure data — the actual
+// SQL lives in SqlStatements, dispatched by id.
+private val DEMO_ROWS =
+  listOf(
+    DemoRow(
+      label = "Direct (no library)",
+      driver =
+        DemoVariant(
+          demo = SqlDemo.DRIVER_DIRECT,
+          transactionName = "SentrySQLiteDriver — Direct",
+          op = "db.sql.driver-direct",
+          displayInfo = DRIVER_DIRECT,
+        ),
+      openHelper =
+        DemoVariant(
+          demo = SqlDemo.OPENHELPER_DIRECT,
+          transactionName = "SentrySupportSQLiteOpenHelper — Direct",
+          op = "db.sql.openhelper-direct",
+          displayInfo = OPENHELPER_DIRECT,
+        ),
+    ),
+    DemoRow(
+      label = "Room 2",
+      driver =
+        DemoVariant(
+          demo = SqlDemo.DRIVER_ROOM2,
+          transactionName = "SentrySQLiteDriver — Room 2",
+          op = "db.sql.driver-room2",
+          displayInfo = DRIVER_ROOM2,
+        ),
+      openHelper =
+        DemoVariant(
+          demo = SqlDemo.OPENHELPER_ROOM,
+          transactionName = "SentrySupportSQLiteOpenHelper — Room",
+          op = "db.sql.openhelper-room",
+          displayInfo = OPENHELPER_ROOM,
+        ),
+    ),
+    DemoRow(
+      label = "Room 3",
+      driver =
+        DemoVariant(
+          demo = SqlDemo.DRIVER_ROOM3,
+          transactionName = "SentrySQLiteDriver — Room 3",
+          op = "db.sql.driver-room3",
+          displayInfo = DRIVER_ROOM3,
+        ),
+      openHelper = null, // Room 3 only runs on the SQLiteDriver path.
+    ),
+    DemoRow(
+      label = "SQLDelight",
+      driver = null, // SQLDelight's AndroidSqliteDriver is built on SupportSQLiteOpenHelper.
+      openHelper =
+        DemoVariant(
+          demo = SqlDemo.OPENHELPER_SQLDELIGHT,
+          transactionName = "SentrySupportSQLiteOpenHelper — SQLDelight",
+          op = "db.sql.openhelper-sqldelight",
+          displayInfo = OPENHELPER_SQLDELIGHT,
+        ),
+    ),
+  )
+
+/**
+ * Activity that lets us exercise our two `sentry-android-sqlite` integrations
+ * ([SentrySQLiteDriver][io.sentry.sqlite.SentrySQLiteDriver] and
+ * [SentrySupportSQLiteOpenHelper][io.sentry.android.sqlite.SentrySupportSQLiteOpenHelper]), both
+ * directly and via Room or SQLDelight.
+ *
+ * Example SQL statements are deliberately identical across integrations so we can identify
+ * similarities and differences in their transaction / span support.
+ */
+class SQLiteActivity : ComponentActivity() {
+
+  private var latestResult by mutableStateOf("")
+  private var sqlDetail by mutableStateOf(SQL_DETAIL_HINT)
+  private var heavyWork by mutableStateOf(false)
+
+  /**
+   * When enabled, every per-button transaction in one screen visit continues [screenTraceHeader],
+   * so they all share a trace ("session"-like). When disabled (the default), each tap is the root
+   * of its own trace, which renders as a standalone waterfall scaled to that one transaction —
+   * easier to read how time is allocated among its spans.
+   */
+  private var shareScreenTrace by mutableStateOf(false)
+
+  /** Which integration the demo buttons target. Switching it disables the rows that don't apply. */
+  private var integration by mutableStateOf(Integration.DRIVER)
+
+  /** Incremented on each tap that runs SQL. Used to retrigger the detail box's outline shimmer. */
+  private var runTick by mutableStateOf(0)
+
+  /** True while a demo or reset is running SQL on a background thread. */
+  private var dbOperationInFlight by mutableStateOf(false)
+
+  /** True for the duration of a reset; disables the reset button immediately (no debounce). */
+  private var resetInProgress by mutableStateOf(false)
+
+  /**
+   * The shared trace used when [shareScreenTrace] is enabled: one trace per visit to this screen.
+   * onResume() generates a fresh one each time the screen is (re)entered.
+   */
+  private var screenTraceHeader = newScreenTrace()
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    setContent {
+      MaterialTheme {
+        Surface {
+          Column(
+            modifier =
+              Modifier.fillMaxWidth()
+                .statusBarsPadding()
+                .padding(16.dp)
+                .verticalScroll(rememberScrollState()),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+          ) {
+            val screenHeightDp = LocalConfiguration.current.screenHeightDp
+            // A small gap below the screen title that grows with screen height and collapses to 0
+            // on short screens, so the title isn't crowded against "Configure it" on tall devices.
+            val titleGap =
+              (((((screenHeightDp / 4) - 48) / 3).coerceAtLeast(0).dp + TOGGLE_SECTION_GAP) / 2 -
+                  SECTION_HEADER_HEIGHT)
+                .coerceAtLeast(0.dp)
+
+            // Pulse the "Under the hood" outline in the integration color whenever a tap runs SQL.
+            val shimmer = remember { Animatable(0f) }
+            LaunchedEffect(runTick) {
+              if (runTick == 0) return@LaunchedEffect
+              shimmer.animateTo(
+                targetValue = 0f,
+                animationSpec =
+                  keyframes {
+                    durationMillis = 900
+                    0f at 0
+                    1f at 200
+                    0.4f at 450
+                    1f at 650
+                    0f at 900
+                  },
+              )
+            }
+
+            val detailOutline =
+              lerp(MaterialTheme.colorScheme.outline, integration.color, shimmer.value)
+
+            Text(text = "SQLite Instrumentation", style = MaterialTheme.typography.headlineSmall)
+
+            Spacer(Modifier.height(titleGap))
+
+            SectionHeader("Configure it")
+
+            val openHelper = integration == Integration.OPEN_HELPER
+            val integrationSwitchColors =
+              SwitchDefaults.colors(
+                checkedTrackColor = SentryPink,
+                checkedBorderColor = SentryPink,
+                uncheckedTrackColor = SentryPurple,
+                uncheckedBorderColor = SentryPurple,
+                uncheckedThumbColor = Color.White,
+              )
+            val controlSwitchColors =
+              SwitchDefaults.colors(
+                checkedTrackColor = Color.Black,
+                checkedBorderColor = Color.Black,
+              )
+            ToggleRow(
+              label = if (openHelper) "SentrySupportSQLiteOpenHelper" else "SentrySQLiteDriver",
+              checked = openHelper,
+              labelColor = if (openHelper) SentryPink else SentryPurple,
+              switchColors = integrationSwitchColors,
+            ) {
+              integration = if (it) Integration.OPEN_HELPER else Integration.DRIVER
+              // Switching integration starts a fresh comparison: clear the detail box and result.
+              sqlDetail = SQL_DETAIL_HINT
+              latestResult = ""
+            }
+            ToggleRow(
+              label = if (heavyWork) "Heavy app-level work" else "No app-level work",
+              checked = heavyWork,
+              switchColors = controlSwitchColors,
+            ) {
+              heavyWork = it
+            }
+            ToggleRow(
+              label =
+                if (shareScreenTrace) "Single trace for all button clicks"
+                else "Separate trace per button click",
+              checked = shareScreenTrace,
+              switchColors = controlSwitchColors,
+            ) {
+              shareScreenTrace = it
+            }
+
+            SectionHeader("Run it", topPadding = CONTROL_SECTION_GAP) { HelpTooltip() }
+
+            // One consolidated list of demo buttons. Each row dispatches to the selected
+            // integration's variant; a row that doesn't apply explains why via a toast (see
+            // [DemoRowButton]).
+            DEMO_ROWS.forEach { row ->
+              val variant = if (integration == Integration.DRIVER) row.driver else row.openHelper
+              DemoRowButton(
+                label = row.label,
+                color = integration.color,
+                variant = variant,
+                disabledReason = "${row.label} doesn't use the ${integration.apiName}",
+              )
+            }
+
+            ResetButton(
+              dbOperationInFlight = dbOperationInFlight,
+              resetInProgress = resetInProgress,
+            )
+
+            // Same [CONTROL_SECTION_GAP] above as the other sections, separating the controls from
+            // the detail output.
+            SectionHeader("Under the hood", topPadding = CONTROL_SECTION_GAP)
+            // The latest run result (row counts, errors). Hidden until the first run.
+            if (latestResult.isNotEmpty()) {
+              Text(
+                text = latestResult,
+                style = MaterialTheme.typography.bodyMedium,
+                color = if (latestResult.contains("failed")) SentryRed else Color.Unspecified,
+              )
+            }
+            DetailField("SQL run", sqlDetail, borderColor = detailOutline)
+          }
+        }
+      }
+    }
+  }
+
+  override fun onResume() {
+    super.onResume()
+    // Start a new trace each time the user (re)enters the screen, so each visit is its own session.
+    screenTraceHeader = newScreenTrace()
+  }
+
+  /** Run the variant's SQL statement inside a manual, scope-bound transaction. */
+  private fun onTap(variant: DemoVariant) {
+    if (dbOperationInFlight) return
+
+    sqlDetail = if (heavyWork) variant.displayInfo.sqlHeavy else variant.displayInfo.sql
+    runTick++ // shimmer the detail box outline in the integration color
+
+    lifecycleScope.launch {
+      dbOperationInFlight = true
+      try {
+        latestResult =
+          withContext(Dispatchers.IO) {
+            runInTransaction(variant.transactionName, variant.op) {
+              SqlStatements.execute(applicationContext, variant.demo, heavyWork)
+            }
+          }
+      } finally {
+        dbOperationInFlight = false
+      }
+    }
+  }
+
+  /**
+   * Run the variant's SQL statement in [UiLoadActivity] with no manual transaction, so its auto
+   * `ui.load` transaction owns the spans.
+   */
+  private fun onLongPress(variant: DemoVariant) {
+    if (dbOperationInFlight) return
+
+    sqlDetail = if (heavyWork) variant.displayInfo.sqlHeavy else variant.displayInfo.sql
+    latestResult = "Opened the auto-load screen — its ui.load transaction owns the db spans."
+    startActivity(UiLoadActivity.intent(this, variant.demo, heavyWork))
+  }
+
+  /**
+   * A compact, left-justified labeled switch. [labelColor] defaults to [Color.Unspecified] so the
+   * label inherits the default text color; the integration toggle passes its pink/purple instead.
+   */
+  @androidx.compose.runtime.Composable
+  private fun ToggleRow(
+    label: String,
+    checked: Boolean,
+    modifier: Modifier = Modifier,
+    labelColor: Color = Color.Unspecified,
+    switchColors: SwitchColors = SwitchDefaults.colors(),
+    onCheckedChange: (Boolean) -> Unit,
+  ) {
+    // Constrain the row height: a Switch otherwise reserves ~48dp, leaving a large gap between the
+    // toggles. 32dp keeps them about one line of text apart.
+    Row(modifier = modifier.height(32.dp), verticalAlignment = Alignment.CenterVertically) {
+      Switch(
+        checked = checked,
+        onCheckedChange = onCheckedChange,
+        colors = switchColors,
+        modifier = Modifier.scale(0.75f),
+      )
+      Text(
+        label,
+        style = MaterialTheme.typography.bodySmall,
+        color = labelColor,
+        modifier = Modifier.padding(start = 4.dp),
+      )
+    }
+  }
+
+  @androidx.compose.runtime.Composable
+  private fun SectionHeader(
+    title: String,
+    topPadding: Dp = 8.dp,
+    trailing: (@androidx.compose.runtime.Composable () -> Unit)? = null,
+  ) {
+    Column(modifier = Modifier.fillMaxWidth().padding(top = topPadding)) {
+      Row(verticalAlignment = Alignment.CenterVertically) {
+        Text(text = title, style = MaterialTheme.typography.titleMedium)
+        trailing?.invoke()
+      }
+      HorizontalDivider(thickness = 1.dp, modifier = Modifier.padding(top = 4.dp))
+    }
+  }
+
+  /**
+   * A circled "?" next to the "Run it" header. Tapping it briefly shows the [INSTRUCTIONS] in a
+   * tooltip that auto-dismisses after a few seconds.
+   */
+  @OptIn(ExperimentalMaterial3Api::class)
+  @androidx.compose.runtime.Composable
+  private fun HelpTooltip() {
+    val tooltipState = rememberTooltipState(isPersistent = true)
+    val scope = rememberCoroutineScope()
+    LaunchedEffect(tooltipState.isVisible) {
+      if (tooltipState.isVisible) {
+        delay(4000)
+        tooltipState.dismiss()
+      }
+    }
+    TooltipBox(
+      positionProvider = TooltipDefaults.rememberPlainTooltipPositionProvider(),
+      tooltip = { PlainTooltip { Text(INSTRUCTIONS) } },
+      state = tooltipState,
+    ) {
+      Icon(
+        imageVector = Icons.Outlined.HelpOutline,
+        contentDescription = "What do the buttons do?",
+        tint = Color.Gray,
+        modifier =
+          Modifier.padding(start = 8.dp).size(20.dp).clickable {
+            scope.launch { tooltipState.show() }
+          },
+      )
+    }
+  }
+
+  /**
+   * A filled button that runs [variant] on tap (manual transaction) or long-press (ui.load). It's a
+   * [Surface] rather than a [Button] because Material3's Button has no long-press hook; the
+   * [combinedClickable] modifier gives us both.
+   *
+   * A null [variant] means the row doesn't apply to the selected integration: the button renders
+   * dimmed and, when clicked, explains why via a toast ([disabledReason]) instead of running.
+   */
+  @OptIn(ExperimentalFoundationApi::class)
+  @androidx.compose.runtime.Composable
+  private fun DemoRowButton(
+    label: String,
+    color: Color,
+    variant: DemoVariant?,
+    disabledReason: String,
+  ) {
+    val context = LocalContext.current
+    val enabled = variant != null
+    val explain = { Toast.makeText(context, disabledReason, Toast.LENGTH_SHORT).show() }
+
+    Surface(
+      modifier = Modifier.fillMaxWidth(),
+      shape = ButtonDefaults.shape,
+      color = if (enabled) color else color.copy(alpha = 0.26f),
+      contentColor = Color.White,
+    ) {
+      Box(
+        modifier =
+          Modifier.combinedClickable(
+              onClick = { if (variant != null) onTap(variant) else explain() },
+              onLongClick = { if (variant != null) onLongPress(variant) else explain() },
+            )
+            .fillMaxWidth()
+            .heightIn(min = 44.dp)
+            .padding(horizontal = 16.dp, vertical = 10.dp),
+        contentAlignment = Alignment.Center,
+      ) {
+        Text(label, style = MaterialTheme.typography.labelLarge)
+      }
+    }
+  }
+
+  @androidx.compose.runtime.Composable
+  private fun ResetButton(dbOperationInFlight: Boolean, resetInProgress: Boolean) {
+    // Debounce demo-driven disablement so fast taps don't flicker the button; reset disables
+    // immediately via [resetInProgress]. [dbOperationInFlight] still guards [onClick] either way.
+    var enabled by remember { mutableStateOf(true) }
+    LaunchedEffect(dbOperationInFlight, resetInProgress) {
+      when {
+        resetInProgress -> enabled = false
+        dbOperationInFlight -> {
+          delay(RESET_DISABLE_DEBOUNCE_MS)
+          enabled = false
+        }
+        else -> enabled = true
+      }
+    }
+
+    Button(
+      modifier = Modifier.fillMaxWidth().padding(top = 8.dp),
+      enabled = enabled,
+      colors = ButtonDefaults.buttonColors(containerColor = Color.Gray, contentColor = Color.White),
+      onClick = {
+        if (dbOperationInFlight) return@Button
+        lifecycleScope.launch {
+          this@SQLiteActivity.resetInProgress = true
+          this@SQLiteActivity.dbOperationInFlight = true
+          try {
+            val message = withContext(Dispatchers.IO) { resetDatabases() }
+            latestResult = message
+            sqlDetail = "DROP: deletes every demo database file, resetting all row counts to 0."
+          } finally {
+            this@SQLiteActivity.dbOperationInFlight = false
+            this@SQLiteActivity.resetInProgress = false
+          }
+        }
+      },
+    ) {
+      Text("Drop all tables (reset)")
+    }
+  }
+
+  @androidx.compose.runtime.Composable
+  private fun DetailField(label: String, value: String, borderColor: Color) {
+    OutlinedTextField(
+      value = value,
+      onValueChange = {},
+      readOnly = true,
+      label = { Text(label) },
+      textStyle = TextStyle(fontFamily = FontFamily.Monospace, fontSize = 12.sp),
+      // The border color is driven by the shimmer animation so the box pulses on each SQL run.
+      colors =
+        OutlinedTextFieldDefaults.colors(
+          focusedBorderColor = borderColor,
+          unfocusedBorderColor = borderColor,
+        ),
+      modifier = Modifier.fillMaxWidth(),
+    )
+  }
+
+  /**
+   * Runs [block] inside a scope-bound transaction and returns the result. When [shareScreenTrace]
+   * is enabled, the transaction continues this screen's trace so all demos in one visit share a
+   * trace; otherwise it starts its own trace (1 transaction = 1 trace).
+   */
+  private suspend fun runInTransaction(
+    transactionName: String,
+    op: String,
+    block: suspend () -> String,
+  ): String {
+    // Continuing the screen trace keeps the shared trace id but mints a fresh span id for this
+    // transaction; the standalone path (and the continueTrace fallback when tracing is disabled)
+    // gives the transaction its own trace.
+    val context =
+      if (shareScreenTrace) {
+        Sentry.continueTrace(screenTraceHeader, null)?.apply {
+          name = transactionName
+          operation = op
+        } ?: TransactionContext(transactionName, op)
+      } else {
+        TransactionContext(transactionName, op)
+      }
+
+    val options = TransactionOptions().apply { isBindToScope = true }
+    val transaction = Sentry.startTransaction(context, options)
+
+    return try {
+      val result = block()
+      transaction.status = SpanStatus.OK
+      result
+    } catch (t: Throwable) {
+      transaction.status = SpanStatus.INTERNAL_ERROR
+      "$transactionName failed: ${t.message}"
+    } finally {
+      transaction.finish()
+    }
+  }
+
+  /** Closes + deletes every demo database file (via [SampleDatabases]), then re-warms them. */
+  private suspend fun resetDatabases(): String {
+    val cleared = SampleDatabases.reset(applicationContext)
+    return "Dropped tables: cleared $cleared database file(s)."
+  }
+
+  private companion object {
+
+    /** Demo SQL shorter than this won't visibly disable the reset button. */
+    private const val RESET_DISABLE_DEBOUNCE_MS = 300L
+
+    /**
+     * Builds a fresh sentry-trace header ("<traceId>-<spanId>-<sampled>") representing this screen
+     * visit's trace. The trailing "-1" marks it sampled so the whole session is kept.
+     */
+    private fun newScreenTrace(): String = "${SentryId()}-${SpanId()}-1"
+  }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt
new file mode 100644
index 00000000000..63f217fcfbb
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt
@@ -0,0 +1,222 @@
+package io.sentry.samples.android.sqlite
+
+import android.content.Context
+import androidx.room.Room
+import androidx.room3.Room as Room3
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.db.SupportSQLiteDatabase
+import androidx.sqlite.db.SupportSQLiteOpenHelper
+import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory
+import androidx.sqlite.driver.bundled.BundledSQLiteDriver
+import androidx.sqlite.execSQL
+import app.cash.sqldelight.driver.android.AndroidSqliteDriver
+import io.sentry.android.sqlite.SentrySupportSQLiteOpenHelper
+import io.sentry.samples.android.sqlite.SampleDatabases.driverDirectLock
+import io.sentry.samples.android.sqlite.SampleDatabases.openHelperDirectLock
+import io.sentry.samples.android.sqlite.SampleDatabases.reset
+import io.sentry.samples.android.sqlite.SampleDatabases.warmUp
+import io.sentry.sqlite.SentrySQLiteDriver
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * Process-lifetime holder for the demo databases used by [SQLiteActivity].
+ *
+ * Real apps open a database once (commonly a DI singleton) and keep it open for the process, so a
+ * screen that touches the DB almost always finds it already "warm". We model that here: [warmUp] is
+ * called from `MyApplication` at launch, off the main thread, so the one-time open + Room
+ * connection-pool bootstrap happens with no active transaction — those `db.sql.query` spans have
+ * nothing to attach to and are dropped. Every screen afterward reuses the warm handle and records
+ * only its statements of interest.
+ *
+ * Handles are held for the whole process: Android has no reliable "app closed" callback, and the OS
+ * reclaims the connections on process death, so we never close them except via [reset] (the "Drop
+ * all tables" button), which closes, deletes the files, and re-warms.
+ *
+ * The two "direct" handles wrap a single raw connection that isn't safe for concurrent use, so
+ * callers serialize their whole unit of work via [driverDirectLock] / [openHelperDirectLock]. Room
+ * and SQLDelight manage their own connection pools and don't need one.
+ */
+object SampleDatabases {
+
+  private val sqlAccess = Mutex()
+
+  val driverDirectLock = Any()
+  val openHelperDirectLock = Any()
+
+  /** Serializes demo SQL and [reset] so handles are never closed mid-statement. */
+  suspend fun <T> withSqlAccess(block: suspend () -> T): T = sqlAccess.withLock { block() }
+
+  @Volatile private var driverConnection: SQLiteConnection? = null
+  @Volatile private var driverRoom2Db: SampleRoom2Database? = null
+  @Volatile private var driverRoom3Db: SampleRoom3Database? = null
+  @Volatile private var directHelper: SupportSQLiteOpenHelper? = null
+  @Volatile private var openHelperRoomDb: SampleRoom2Database? = null
+  @Volatile private var sqlDelightDriver: AndroidSqliteDriver? = null
+
+  fun driverConnection(context: Context): SQLiteConnection =
+    synchronized(driverDirectLock) {
+      driverConnection
+        ?: SentrySQLiteDriver.create(BundledSQLiteDriver())
+          .open(databaseFile(context, "driver_direct.db"))
+          .also {
+            it.execSQL(SqlStatements.CREATE_SONG) // one-time table setup, at open
+            driverConnection = it
+          }
+    }
+
+  fun driverRoom2Db(context: Context): SampleRoom2Database =
+    synchronized(this) {
+      driverRoom2Db
+        ?: Room.databaseBuilder(
+            context.applicationContext,
+            SampleRoom2Database::class.java,
+            "driver_room2.db",
+          )
+          .setDriver(SentrySQLiteDriver.create(BundledSQLiteDriver()))
+          .setQueryCoroutineContext(Dispatchers.IO)
+          .fallbackToDestructiveMigration(true)
+          .build()
+          .also { driverRoom2Db = it }
+    }
+
+  fun driverRoom3Db(context: Context): SampleRoom3Database =
+    synchronized(this) {
+      driverRoom3Db
+        ?: Room3.databaseBuilder<SampleRoom3Database>(context.applicationContext, "driver_room3.db")
+          .setDriver(SentrySQLiteDriver.create(BundledSQLiteDriver()))
+          .setQueryCoroutineContext(Dispatchers.IO)
+          .build()
+          .also { driverRoom3Db = it }
+    }
+
+  fun directHelper(context: Context): SupportSQLiteOpenHelper =
+    synchronized(openHelperDirectLock) {
+      directHelper ?: buildDirectHelper(context).also { directHelper = it }
+    }
+
+  fun openHelperRoomDb(context: Context): SampleRoom2Database =
+    synchronized(this) {
+      openHelperRoomDb
+        ?: Room.databaseBuilder(
+            context.applicationContext,
+            SampleRoom2Database::class.java,
+            "openhelper_room.db",
+          )
+          .openHelperFactory { configuration ->
+            SentrySupportSQLiteOpenHelper.create(
+              FrameworkSQLiteOpenHelperFactory().create(configuration)
+            )
+          }
+          .fallbackToDestructiveMigration(true)
+          .build()
+          .also { openHelperRoomDb = it }
+    }
+
+  fun sqlDelightDriver(context: Context): AndroidSqliteDriver =
+    synchronized(this) {
+      sqlDelightDriver
+        ?: AndroidSqliteDriver(
+            schema = SampleSQLDelightDatabase.Schema,
+            context = context.applicationContext,
+            name = "openhelper_sqldelight.db",
+            factory =
+              SupportSQLiteOpenHelper.Factory { configuration ->
+                SentrySupportSQLiteOpenHelper.create(
+                  FrameworkSQLiteOpenHelperFactory().create(configuration)
+                )
+              },
+          )
+          .also { sqlDelightDriver = it }
+    }
+
+  private fun buildDirectHelper(context: Context): SupportSQLiteOpenHelper {
+    val configuration =
+      SupportSQLiteOpenHelper.Configuration.builder(context.applicationContext)
+        .name("openhelper_direct.db")
+        .callback(
+          object : SupportSQLiteOpenHelper.Callback(1) {
+            override fun onCreate(db: SupportSQLiteDatabase) {
+              db.execSQL(SqlStatements.CREATE_SONG)
+            }
+
+            override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) =
+              Unit
+          }
+        )
+        .build()
+    return SentrySupportSQLiteOpenHelper.create(
+      FrameworkSQLiteOpenHelperFactory().create(configuration)
+    )
+  }
+
+  /** Opens every database on a background thread, forcing the one-time open + bootstrap to run. */
+  fun warmUp(context: Context) {
+    val appContext = context.applicationContext
+    // Fire-and-forget: the warm-up outlives no particular screen, so a bare scope is fine here.
+    CoroutineScope(Dispatchers.IO).launch {
+      runCatching { driverConnection(appContext) }
+      // primeWriter() + count() opens both Room pool connections (writer + reader), so the first
+      // demo INSERT/SELECT reuses them instead of bootstrapping a connection inside its
+      // transaction.
+      runCatching { driverRoom2Db(appContext).songDao().also { it.primeWriter() }.count() }
+      runCatching { driverRoom3Db(appContext).songDao().also { it.primeWriter() }.count() }
+      runCatching { directHelper(appContext).writableDatabase }
+      runCatching { openHelperRoomDb(appContext).songDao().also { it.primeWriter() }.count() }
+      runCatching {
+        SampleSQLDelightDatabase(sqlDelightDriver(appContext))
+          .songQueries
+          .countSongs()
+          .executeAsOne()
+      }
+    }
+  }
+
+  /**
+   * Closes the open handles, deletes every demo database file, then re-warms. Returns the number of
+   * files cleared. Waits for any in-flight demo SQL (including [UiLoadActivity]) to finish first.
+   */
+  suspend fun reset(context: Context): Int = withSqlAccess {
+    closeAll()
+    val appContext = context.applicationContext
+    val names =
+      listOf(
+        "driver_direct.db",
+        "driver_room2.db",
+        "driver_room3.db",
+        "openhelper_direct.db",
+        "openhelper_room.db",
+        "openhelper_sqldelight.db",
+      )
+    val cleared = names.count { appContext.deleteDatabase(it) }
+    warmUp(appContext)
+    cleared
+  }
+
+  private fun closeAll() {
+    synchronized(driverDirectLock) {
+      driverConnection?.close()
+      driverConnection = null
+    }
+    synchronized(openHelperDirectLock) {
+      directHelper?.close()
+      directHelper = null
+    }
+    synchronized(this) {
+      driverRoom2Db?.close()
+      driverRoom2Db = null
+      driverRoom3Db?.close()
+      driverRoom3Db = null
+      openHelperRoomDb?.close()
+      openHelperRoomDb = null
+      sqlDelightDriver?.close()
+      sqlDelightDriver = null
+    }
+  }
+
+  private fun databaseFile(context: Context, name: String): String =
+    context.applicationContext.getDatabasePath(name).also { it.parentFile?.mkdirs() }.absolutePath
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Song.sq b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Song.sq
new file mode 100644
index 00000000000..345e55a3582
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/Song.sq
@@ -0,0 +1,17 @@
+CREATE TABLE song (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  title TEXT NOT NULL,
+  artist TEXT NOT NULL
+);
+
+insertSong:
+INSERT INTO song(title, artist)
+VALUES (?, ?);
+
+selectAll:
+SELECT *
+FROM song;
+
+countSongs:
+SELECT count(*)
+FROM song;
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SqlStatements.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SqlStatements.kt
new file mode 100644
index 00000000000..543f1169294
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SqlStatements.kt
@@ -0,0 +1,226 @@
+package io.sentry.samples.android.sqlite
+
+import android.content.Context
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.db.SupportSQLiteDatabase
+
+/**
+ * Rows inserted (and then consumed + processed) per demo when "heavy application-level work" is
+ * enabled.
+ */
+private const val HEAVY_ROW_COUNT = 50
+
+/**
+ * Identifies a single SQLite demo: one of the two integrations crossed with the way it's used
+ * (raw/direct, Room, or SQLDelight). Used to dispatch the same SQL from both trace styles.
+ */
+enum class SqlDemo {
+  DRIVER_DIRECT,
+  DRIVER_ROOM2,
+  DRIVER_ROOM3,
+  OPENHELPER_DIRECT,
+  OPENHELPER_ROOM,
+  OPENHELPER_SQLDELIGHT,
+}
+
+/**
+ * Executable SQL and demo runners for the SQLite sample screens. The human-readable "SQL run"
+ * summaries shown in the UI live in the per-demo [DisplayInfo] constants; keep those in lockstep
+ * with the statements here.
+ *
+ * The actual SQL each demo runs is kept separate from how its trace is created so the two screens
+ * can share it:
+ * - [SQLiteActivity]: Wraps [execute] in a manual `Sentry.startTransaction(…)`.
+ * - [UiLoadActivity]: Calls the same [execute] with no manual transaction, so the screen's auto
+ *   `ui.load` transaction owns the resulting `db.sql.query` spans.
+ *
+ * All demos read the shared, already-warm handles from [SampleDatabases] and return a short status
+ * line. [heavy] mirrors the screen's "heavy app-level work" toggle. When enabled, each demo also
+ * batch inserts [HEAVY_ROW_COUNT] rows and consumes them with per-row [appWork].
+ */
+object SqlStatements {
+
+  const val CREATE_SONG =
+    "CREATE TABLE IF NOT EXISTS song(id INTEGER PRIMARY KEY, title TEXT, artist TEXT)"
+  const val INSERT_SONG = "INSERT INTO song(title, artist) VALUES (?, ?)"
+  const val SELECT_SONGS = "SELECT id, title, artist FROM song"
+  const val COUNT_SONGS = "SELECT count(*) FROM song"
+
+  /**
+   * A single multi-row INSERT for [rowCount] songs, bound with [batchSongArgs]. One statement <>
+   * one round-trip, which is the realistic way to add a known batch of rows, rather than a loop of
+   * [rowCount] single-row inserts.
+   */
+  fun insertSongsBatch(rowCount: Int): String =
+    "INSERT INTO song(title, artist) VALUES " + List(rowCount) { "(?, ?)" }.joinToString(", ")
+
+  /** Flattened title/artist bind args for [insertSongsBatch]: "song 0", "artist 0", "song 1", … */
+  fun batchSongArgs(rowCount: Int): Array<Any?> =
+    Array(rowCount * 2) { i -> if (i % 2 == 0) "song ${i / 2}" else "artist ${i / 2}" }
+
+  suspend fun execute(context: Context, demo: SqlDemo, heavy: Boolean): String =
+    SampleDatabases.withSqlAccess {
+      when (demo) {
+        SqlDemo.DRIVER_DIRECT -> driverDirect(context, heavy)
+        SqlDemo.DRIVER_ROOM2 -> driverWithRoom2(context, heavy)
+        SqlDemo.DRIVER_ROOM3 -> driverWithRoom3(context, heavy)
+        SqlDemo.OPENHELPER_DIRECT -> openHelperDirect(context, heavy)
+        SqlDemo.OPENHELPER_ROOM -> openHelperWithRoom(context, heavy)
+        SqlDemo.OPENHELPER_SQLDELIGHT -> openHelperWithSqlDelight(context, heavy)
+      }
+    }
+
+  // --- 1. SentrySQLiteDriver, used directly -------------------------------------------------
+
+  private fun driverDirect(context: Context, heavy: Boolean): String =
+    synchronized(SampleDatabases.driverDirectLock) {
+      val connection = SampleDatabases.driverConnection(context)
+      insert(connection, "Mishima / Closing", "Philip Glass")
+      insert(connection, "School of Velocity, op 299 no 1, ", "Carl Czerny")
+
+      if (heavy) {
+        // One multi-row INSERT for all HEAVY_ROWS rows, rather than a naive loop of single-row
+        // inserts.
+        connection.prepare(insertSongsBatch(HEAVY_ROW_COUNT)).use { statement ->
+          var param = 1
+          repeat(HEAVY_ROW_COUNT) { row ->
+            statement.bindText(param++, "song $row")
+            statement.bindText(param++, "artist $row")
+          }
+          statement.step()
+        }
+
+        connection.prepare(SELECT_SONGS).use { statement ->
+          while (statement.step()) {
+            // Consumption: pull each column across the JNI boundary into the ART heap.
+            val row = "${statement.getLong(0)}:${statement.getText(1)}:${statement.getText(2)}"
+            // Application work: e.g. per-row decryption.
+            appWork(row)
+          }
+        }
+      }
+      "Driver (Direct): ${count(connection)} rows."
+    }
+
+  private fun insert(connection: SQLiteConnection, title: String, artist: String) {
+    connection.prepare(INSERT_SONG).use { statement ->
+      statement.bindText(1, title)
+      statement.bindText(2, artist)
+      statement.step()
+    }
+  }
+
+  private fun count(connection: SQLiteConnection): Long =
+    connection.prepare(COUNT_SONGS).use { statement ->
+      if (statement.step()) statement.getLong(0) else 0
+    }
+
+  // --- 2. SentrySQLiteDriver, used through Room 2.7+ ----------------------------------------
+
+  private suspend fun driverWithRoom2(context: Context, heavy: Boolean): String =
+    roomDemo(SampleDatabases.driverRoom2Db(context).songDao(), "Driver (Room 2)", heavy)
+
+  /**
+   * Shared Room 2 demo so the driver and open-helper paths run *identical* SQL. The only difference
+   * is how each integration instruments it: the driver spans every read, while the open helper's
+   * Room reads go via `moveToNext()` and emit no span, so only the INSERTs are spanned.
+   */
+  private suspend fun roomDemo(dao: SongDao, label: String, heavy: Boolean): String {
+    dao.insert(SongEntity(title = "Spiders (Kidsmoke)", artist = "Wilco"))
+    if (heavy) {
+      // Batch insert: one insertAll() runs all rows in a single transaction, vs. a per-row loop.
+      dao.insertAll(List(HEAVY_ROW_COUNT) { SongEntity(title = "song $it", artist = "artist $it") })
+      dao.getAll().forEach { appWork("${it.id}:${it.title}:${it.artist}") }
+    }
+    return "$label: ${dao.count()} rows."
+  }
+
+  // --- 2b. SentrySQLiteDriver, used through Room 3.0+ (androidx.room3) -----------------------
+
+  private suspend fun driverWithRoom3(context: Context, heavy: Boolean): String {
+    val dao = SampleDatabases.driverRoom3Db(context).songDao()
+    dao.insert(SongEntity3(title = "What's Up", artist = "4 Non Blondes"))
+    if (heavy) {
+      // Batch insert: one insertAll() runs all rows in a single transaction, vs. a naive per-row
+      // loop.
+      dao.insertAll(
+        List(HEAVY_ROW_COUNT) { SongEntity3(title = "song $it", artist = "artist $it") }
+      )
+      dao.getAll().forEach { appWork("${it.id}:${it.title}:${it.artist}") }
+    }
+    return "Driver (Room 3): ${dao.count()} rows."
+  }
+
+  // --- 3. SentrySupportSQLiteOpenHelper, used directly --------------------------------------
+
+  private fun openHelperDirect(context: Context, heavy: Boolean): String =
+    synchronized(SampleDatabases.openHelperDirectLock) {
+      // Runs the *same* SQL as driverDirect(), so the only difference you see in the Sentry UI is
+      // how each integration instruments identical statements.
+      val db = SampleDatabases.directHelper(context).writableDatabase
+      db.execSQL(INSERT_SONG, arrayOf("Mishima / Closing", "Philip Glass"))
+      db.execSQL(INSERT_SONG, arrayOf("School of Velocity, op 299 no 1, ", "Carl Czerny"))
+      if (heavy) {
+        // One multi-row INSERT for all HEAVY_ROWS rows, rather than a naive loop of single-row
+        // inserts.
+        db.execSQL(insertSongsBatch(HEAVY_ROW_COUNT), batchSongArgs(HEAVY_ROW_COUNT))
+        db.query(SELECT_SONGS).use { cursor ->
+          while (cursor.moveToNext()) {
+            // Consumption: read each column out of the cursor window.
+            val row = "${cursor.getLong(0)}:${cursor.getString(1)}:${cursor.getString(2)}"
+            // Application work: e.g. per-row decryption.
+            appWork(row)
+          }
+        }
+      }
+      "OpenHelper (Direct): ${querySongCount(db)} rows."
+    }
+
+  /**
+   * Runs the shared `SELECT count(*)` through the open helper and returns the value, read the
+   * normal way: moveToFirst() + getInt(). These are delegated straight to the underlying cursor
+   * (the open helper only instruments getCount()/onMove()/fillWindow()), so this read produces no
+   * `db.sql.query` span — the same as a real app reading a scalar count.
+   */
+  private fun querySongCount(db: SupportSQLiteDatabase): Int =
+    db.query(COUNT_SONGS).use { cursor ->
+      cursor.moveToFirst()
+      cursor.getInt(0)
+    }
+
+  // --- 4. SentrySupportSQLiteOpenHelper, used through Room ----------------------------------
+
+  // Runs the same [roomDemo] SQL as the driver path; only the instrumentation differs.
+  private suspend fun openHelperWithRoom(context: Context, heavy: Boolean): String =
+    roomDemo(SampleDatabases.openHelperRoomDb(context).songDao(), "OpenHelper (Room)", heavy)
+
+  // --- 5. SentrySupportSQLiteOpenHelper, used through SQLDelight ----------------------------
+
+  private fun openHelperWithSqlDelight(context: Context, heavy: Boolean): String {
+    val database = SampleSQLDelightDatabase(SampleDatabases.sqlDelightDriver(context))
+    database.songQueries.insertSong("Nightcall", "Kavinsky")
+    if (heavy) {
+      // Wrap the batch in one transaction, vs. each insertSong() naively committing on its own.
+      database.transaction {
+        repeat(HEAVY_ROW_COUNT) { database.songQueries.insertSong("song $it", "artist $it") }
+      }
+      database.songQueries.selectAll().executeAsList().forEach {
+        appWork("${it.id}:${it.title}:${it.artist}")
+      }
+    }
+    // SQLDelight reads its cursor only via moveToNext(), which is delegated past the wrapper, so
+    // this count read produces no span.
+    val count = database.songQueries.countSongs().executeAsOne()
+    return "OpenHelper (SQLDelight): $count rows."
+  }
+
+  /**
+   * Simulates per-row application-level work (e.g. decrypting a column) on consumed results. This
+   * is deliberately CPU-heavy and unrelated to the SQLite engine.
+   */
+  private fun appWork(value: String) {
+    val digest = java.security.MessageDigest.getInstance("SHA-256")
+    var bytes = value.toByteArray()
+    repeat(500) { bytes = digest.digest(bytes) }
+  }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadActivity.kt
new file mode 100644
index 00000000000..b32811e8c91
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadActivity.kt
@@ -0,0 +1,69 @@
+package io.sentry.samples.android.sqlite
+
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.lifecycle.lifecycleScope
+import io.sentry.Sentry
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/**
+ * Activity that lets us simulate SDK auto-generation of a `ui.load` transaction + attach SQLite
+ * statement spans to it.
+ *
+ * Timing note: the work runs off the main thread, so it finishes after the screen is first drawn.
+ * Time-to-full-display tracing (enabled in the manifest) keeps the `ui.load` transaction open until
+ * [Sentry.reportFullyDisplayed], which we call once the work completes — otherwise the transaction
+ * would auto-finish at first display and the late db spans would have nowhere to attach.
+ */
+class UiLoadActivity : ComponentActivity() {
+
+  private var status by mutableStateOf("Running under the screen's auto ui.load transaction…")
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    val id =
+      SqlDemo.entries.find { it.name == intent.getStringExtra(EXTRA_DEMO_ID) }
+        ?: run {
+          finish()
+          return
+        }
+    val heavy = intent.getBooleanExtra(EXTRA_HEAVY, false)
+
+    setContent { UiLoadScreen(status = status, onClose = ::finish) }
+
+    // No Sentry.startTransaction(): the work runs under the auto ui.load:UiLoadActivity span.
+    lifecycleScope.launch {
+      status =
+        try {
+          val result =
+            withContext(Dispatchers.IO) { SqlStatements.execute(applicationContext, id, heavy) }
+          "$result\n\nRan under the auto ui.load transaction."
+        } catch (t: Throwable) {
+          "Load failed: ${t.message}"
+        } finally {
+          // Close the TTFD window so the ui.load transaction finishes with the db spans attached.
+          Sentry.reportFullyDisplayed()
+        }
+    }
+  }
+
+  companion object {
+    private const val EXTRA_DEMO_ID = "demo_id"
+    private const val EXTRA_HEAVY = "heavy"
+
+    /** Builds the intent that runs [id] (honoring the [heavy] toggle) on this UiLoadScreen. */
+    fun intent(context: Context, id: SqlDemo, heavy: Boolean): Intent =
+      Intent(context, UiLoadActivity::class.java)
+        .putExtra(EXTRA_DEMO_ID, id.name)
+        .putExtra(EXTRA_HEAVY, heavy)
+  }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadScreen.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadScreen.kt
new file mode 100644
index 00000000000..6495726448d
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadScreen.kt
@@ -0,0 +1,110 @@
+package io.sentry.samples.android.sqlite
+
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.LinearEasing
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.offset
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.statusBarsPadding
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.BlendMode
+import androidx.compose.ui.graphics.Brush
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.CompositingStrategy
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.unit.dp
+import io.sentry.samples.android.R
+
+private val ShimmerHighlight = Color(0xFFBDBDBD)
+
+@Composable
+fun UiLoadScreen(status: String, onClose: () -> Unit) {
+  MaterialTheme {
+    Surface {
+      Box(
+        modifier = Modifier.fillMaxSize().statusBarsPadding().navigationBarsPadding().padding(24.dp)
+      ) {
+        Column(
+          modifier = Modifier.align(Alignment.Center).fillMaxWidth().offset(y = (-48).dp),
+          horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+          ShimmerSentryGlyph(modifier = Modifier.size(96.dp))
+          Spacer(modifier = Modifier.height(24.dp))
+          Text(
+            text = status,
+            style = MaterialTheme.typography.bodyLarge,
+            textAlign = TextAlign.Center,
+          )
+        }
+
+        Button(
+          onClick = onClose,
+          modifier = Modifier.align(Alignment.BottomCenter).fillMaxWidth(),
+          colors =
+            ButtonDefaults.buttonColors(containerColor = Color.Black, contentColor = Color.White),
+        ) {
+          Text("Close")
+        }
+      }
+    }
+  }
+}
+
+@Composable
+private fun ShimmerSentryGlyph(modifier: Modifier = Modifier) {
+  val progress = remember { Animatable(0f) }
+  LaunchedEffect(Unit) {
+    progress.animateTo(
+      targetValue = 1f,
+      animationSpec = tween(durationMillis = 700, delayMillis = 250, easing = LinearEasing),
+    )
+  }
+
+  Image(
+    painter = painterResource(R.drawable.sentry_glyph),
+    contentDescription = "Sentry",
+    modifier =
+      modifier
+        .graphicsLayer { compositingStrategy = CompositingStrategy.Offscreen }
+        .drawWithContent {
+          drawContent()
+          val p = progress.value
+          val band = size.width * 0.5f
+          // Sweep the highlight band diagonally from off the bottom-left corner (p=0) to off the
+          // top-right corner (p=1): x travels left→right, y travels bottom→top.
+          val x = -band + (size.width + 2f * band) * p
+          val y = (size.height + band) - (size.height + 2f * band) * p
+          drawRect(
+            brush =
+              Brush.linearGradient(
+                colors = listOf(Color.Black, ShimmerHighlight, Color.Black),
+                start = Offset(x, y),
+                end = Offset(x + band, y - band),
+              ),
+            blendMode = BlendMode.SrcAtop,
+          )
+        },
+  )
+}

From 7c1a728e8bd2faa42b8f1c25c9f16a145baab60f Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Thu, 18 Jun 2026 12:38:54 +0200
Subject: [PATCH 214/391] chore(android-sqlite): Skip wrapping
 SupportSQLiteDriver bridge to avoid duplicate spans (#5514)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SentrySQLiteDriver.create() now recognizes the Room 2.7+ androidx.sqlite.driver.SupportSQLiteDriver bridge adapter and returns it unwrapped. That lets us protect against the one known vector where using both SentrySQLiteDriver and SentrySupportSQLiteOpenHelper with the same db table is allowed under either the Room or SQLDelight APIs:

```kotlin
// AVOID — this configuration produces duplicate spans for every SQL statement.

// Step 1: Developer wraps their open helper with Sentry, either manually or
// via the Sentry Android Gradle Plugin.
val sentryWrappedHelper: SupportSQLiteOpenHelper =
    SentrySupportSQLiteOpenHelper.create(
        FrameworkSQLiteOpenHelperFactory().create(configuration)
    )

// Step 2: Developer builds the compat driver around that wrapped helper.
val driver: SQLiteDriver = SupportSQLiteDriver(sentryWrappedHelper)

// Step 3: Developer (wrongly!) wraps the driver with Sentry as well. All
// spans will now be duplicated.
val sentryWrappedDriver: SQLiteDriver = SentrySQLiteDriver.create(driver)

Room.databaseBuilder(context, MyDb::class.java, "mydb")
    .setDriver(sentryWrappedDriver)
    .build()
```

This commit lets us avoid step 3 by no-op'ing if a developer tries to pass a SupportSQLiteDriver to SentrySQLiteDriver.create().
---
 sentry-android-sqlite/proguard-rules.pro      |   4 +
 .../io/sentry/sqlite/SentrySQLiteDriver.kt    |  32 ++-
 .../sqlite/driver/SupportSQLiteDriver.kt      |  18 ++
 .../sentry/sqlite/SentrySQLiteDriverTest.kt   |  11 ++
 .../samples/android/sqlite/DisplayInfo.kt     |   5 +
 .../samples/android/sqlite/SQLiteActivity.kt  | 183 ++++++++++++++----
 .../samples/android/sqlite/SampleDatabases.kt | 181 +++++++++++++++--
 .../samples/android/sqlite/SqlStatements.kt   |  35 ++++
 .../samples/android/sqlite/UiLoadActivity.kt  |   5 +-
 9 files changed, 412 insertions(+), 62 deletions(-)
 create mode 100644 sentry-android-sqlite/src/test/java/androidx/sqlite/driver/SupportSQLiteDriver.kt

diff --git a/sentry-android-sqlite/proguard-rules.pro b/sentry-android-sqlite/proguard-rules.pro
index 02ab589d3bd..13fa4bf9dea 100644
--- a/sentry-android-sqlite/proguard-rules.pro
+++ b/sentry-android-sqlite/proguard-rules.pro
@@ -4,4 +4,8 @@
 # https://developer.android.com/studio/build/shrink-code#decode-stack-trace
 -keepattributes LineNumberTable,SourceFile
 
+# SentrySQLiteDriver.create() uses a runtime class-name check to skip wrapping the Room 2.7+
+# SupportSQLiteDriver bridge adapter and avoid duplicate spans.
+-keepnames class androidx.sqlite.driver.SupportSQLiteDriver
+
 ##---------------End: proguard configuration for SQLite  ----------
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
index e869778b811..f0f41782c22 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
@@ -22,11 +22,6 @@ import org.jetbrains.annotations.ApiStatus
  *     .build()
  * ```
  *
- * **Warning:** Do not use [SentrySQLiteDriver] together with
- * [SentrySupportSQLiteOpenHelper][io.sentry.android.sqlite.SentrySupportSQLiteOpenHelper] on the
- * same database file. Both wrappers instrument at different layers and combining them will produce
- * duplicate spans.
- *
  * @param delegate The [SQLiteDriver] instance to delegate calls to.
  */
 @ApiStatus.Experimental
@@ -73,11 +68,32 @@ public class SentrySQLiteDriver private constructor(private val delegate: SQLite
   public companion object {
 
     /**
-     * Wraps the provided delegate in a [SentrySQLiteDriver]. Returns the delegate as-is if already
-     * wrapped.
+     * Name of the bridge adapter often used with Room 2.7+. It implements the `SQLiteDriver`
+     * interface and its constructor consumes a `SupportSQLiteOpenHelper`. (Users of the Sentry
+     * Android Gradle Plugin will have the `SupportSQLiteOpenHelper` wrapped for them
+     * automatically.) We deliberately avoid wrapping the adapter to prevent duplicate spans.
+     *
+     * String (rather than an `is` check) lets us avoid a compile-time dependency on
+     * androidx.sqlite:sqlite-framework.
+     */
+    private const val SUPPORT_SQLITE_DRIVER_FQN = "androidx.sqlite.driver.SupportSQLiteDriver"
+
+    /**
+     * Wraps the provided delegate in a [SentrySQLiteDriver].
+     *
+     * To avoid duplicate spans, returns the delegate as-is if:
+     * 1. it's already wrapped, or
+     * 2. it's an `androidx.sqlite.driver.SupportSQLiteDriver`.
+     *
+     * In the case of (2), wrap the open helper passed to the `SupportSQLiteDriver` constructor via
+     * `SentrySupportSQLiteOpenHelper` instead.
      */
     @JvmStatic
     public fun create(delegate: SQLiteDriver): SQLiteDriver =
-      delegate as? SentrySQLiteDriver ?: SentrySQLiteDriver(delegate)
+      if (delegate is SentrySQLiteDriver || delegate.javaClass.name == SUPPORT_SQLITE_DRIVER_FQN) {
+        delegate
+      } else {
+        SentrySQLiteDriver(delegate)
+      }
   }
 }
diff --git a/sentry-android-sqlite/src/test/java/androidx/sqlite/driver/SupportSQLiteDriver.kt b/sentry-android-sqlite/src/test/java/androidx/sqlite/driver/SupportSQLiteDriver.kt
new file mode 100644
index 00000000000..2de7f1d38f5
--- /dev/null
+++ b/sentry-android-sqlite/src/test/java/androidx/sqlite/driver/SupportSQLiteDriver.kt
@@ -0,0 +1,18 @@
+package androidx.sqlite.driver
+
+import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.SQLiteDriver
+
+/**
+ * Minimal stub of `androidx.sqlite.driver.SupportSQLiteDriver` (which lives in
+ * `androidx.sqlite:sqlite-framework`, not on this module's compile/test classpath) for verifying
+ * behavior of `SentrySQLiteDriver.create(SupportSQLiteDriver)`.
+ */
+internal class SupportSQLiteDriver : SQLiteDriver {
+
+  override val hasConnectionPool: Boolean = false
+
+  override fun open(fileName: String): SQLiteConnection {
+    throw UnsupportedOperationException("Test stub; not for runtime use")
+  }
+}
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteDriverTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteDriverTest.kt
index 9b2345a975f..5816f3d859c 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteDriverTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteDriverTest.kt
@@ -3,6 +3,7 @@ package io.sentry.sqlite
 import androidx.sqlite.SQLiteConnection
 import androidx.sqlite.SQLiteDriver
 import androidx.sqlite.SQLiteStatement
+import androidx.sqlite.driver.SupportSQLiteDriver
 import io.sentry.IScopes
 import io.sentry.Sentry
 import io.sentry.SentryIntegrationPackageStorage
@@ -64,6 +65,16 @@ class SentrySQLiteDriverTest {
     assertSame(wrapped, doubleWrapped)
   }
 
+  @Test
+  fun `create with SupportSQLiteDriver bridge returns same instance without wrapping`() {
+    val bridge = SupportSQLiteDriver()
+
+    val result = SentrySQLiteDriver.create(bridge)
+
+    assertSame(bridge, result)
+    assertFalse(result is SentrySQLiteDriver)
+  }
+
   @Test
   fun `hasConnectionPool forwards delegate value when supported`() {
     whenever(fixture.mockDriver.hasConnectionPool).thenReturn(true)
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/DisplayInfo.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/DisplayInfo.kt
index 14582fe305e..fd80a5aae1e 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/DisplayInfo.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/DisplayInfo.kt
@@ -87,6 +87,11 @@ internal val OPENHELPER_ROOM =
         .trimIndent(),
   )
 
+// Bridge demos run the same SQL as the driver paths; spans come from the open-helper layer.
+internal val BRIDGE_DIRECT = DRIVER_DIRECT
+
+internal val BRIDGE_ROOM2 = DRIVER_ROOM2
+
 internal val OPENHELPER_SQLDELIGHT =
   DisplayInfo(
     sql =
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt
index 1ff6828a757..9a27ecda353 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt
@@ -1,6 +1,7 @@
 package io.sentry.samples.android.sqlite
 
 import android.os.Bundle
+import android.util.Log
 import android.widget.Toast
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
@@ -33,6 +34,9 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedTextField
 import androidx.compose.material3.OutlinedTextFieldDefaults
 import androidx.compose.material3.PlainTooltip
+import androidx.compose.material3.SegmentedButton
+import androidx.compose.material3.SegmentedButtonDefaults
+import androidx.compose.material3.SingleChoiceSegmentedButtonRow
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Switch
 import androidx.compose.material3.SwitchColors
@@ -73,6 +77,7 @@ import kotlinx.coroutines.withContext
 
 private val SentryPink = Color(0xFFC85B9C)
 private val SentryPurple = Color(0xFF7B52FB)
+private val SentryOrange = Color(0xFFE8743F)
 private val SentryRed = Color(0xFFF55459)
 
 /** Intro text, surfaced via the "?" tooltip next to the "Run it" header. */
@@ -88,10 +93,33 @@ private val CONTROL_SECTION_GAP = TOGGLE_SECTION_GAP * 2
 
 private val SECTION_HEADER_HEIGHT = 28.dp
 
-/** Which sentry-android-sqlite integration the demo buttons currently target. */
-private enum class Integration(val color: Color, val apiName: String) {
-  DRIVER(SentryPurple, "SQLiteDriver"),
-  OPEN_HELPER(SentryPink, "SupportSQLiteOpenHelper"),
+/** Which sentry-android-sqlite integration the demo currently targets. */
+private enum class IntegrationMode(
+  val color: Color,
+  val segmentLabel: String,
+  val apiName: String,
+  val subtitle: String,
+) {
+  DRIVER(
+    SentryPurple,
+    "SQLiteDriver",
+    "SQLiteDriver",
+    "SentrySQLiteDriver.create(BundledSQLiteDriver)",
+  ),
+  OPEN_HELPER(
+    SentryPink,
+    "OpenHelper",
+    "SupportSQLiteOpenHelper",
+    "SentrySupportSQLiteOpenHelper.create(...)",
+  ),
+  // Not directly-supported, but lets us verify behavior when both the DRIVER and OPEN_HELPER
+  // integrations are used together via the SupportSQLiteDriver bridge.
+  BRIDGE(
+    SentryOrange,
+    "Bridge",
+    "SupportSQLiteDriver bridge",
+    "SentrySQLiteDriver.create(SupportSQLiteDriver(Sentry helper))",
+  ),
 }
 
 /**
@@ -107,11 +135,24 @@ private class DemoVariant(
 )
 
 /**
- * A single demo button in the list. [driver] / [openHelper] hold the variant for each integration;
- * a null variant means the row doesn't apply to that integration and renders dimmed, explaining why
- * on click (Room 3 is driver-only; SQLDelight is open-helper-only).
+ * A single demo button in the list. [driver] / [openHelper] / [bridge] hold the variant for each
+ * integration; a null variant means the row doesn't apply and renders dimmed (e.g., Room 3 is
+ * driver-only; SQLDelight is open-helper-only; etc.).
  */
-private class DemoRow(val label: String, val driver: DemoVariant?, val openHelper: DemoVariant?)
+private class DemoRow(
+  val label: String,
+  val driver: DemoVariant?,
+  val openHelper: DemoVariant?,
+  val bridge: DemoVariant?,
+) {
+
+  fun variantFor(mode: IntegrationMode): DemoVariant? =
+    when (mode) {
+      IntegrationMode.DRIVER -> driver
+      IntegrationMode.OPEN_HELPER -> openHelper
+      IntegrationMode.BRIDGE -> bridge
+    }
+}
 
 // The demo buttons, top to bottom, paired with each integration's variant. Pure data — the actual
 // SQL lives in SqlStatements, dispatched by id.
@@ -133,6 +174,13 @@ private val DEMO_ROWS =
           op = "db.sql.openhelper-direct",
           displayInfo = OPENHELPER_DIRECT,
         ),
+      bridge =
+        DemoVariant(
+          demo = SqlDemo.BRIDGE_DIRECT,
+          transactionName = "Bridge stack — Direct",
+          op = "db.sql.bridge-direct",
+          displayInfo = BRIDGE_DIRECT,
+        ),
     ),
     DemoRow(
       label = "Room 2",
@@ -150,6 +198,13 @@ private val DEMO_ROWS =
           op = "db.sql.openhelper-room",
           displayInfo = OPENHELPER_ROOM,
         ),
+      bridge =
+        DemoVariant(
+          demo = SqlDemo.BRIDGE_ROOM2,
+          transactionName = "Bridge stack — Room 2",
+          op = "db.sql.bridge-room2",
+          displayInfo = BRIDGE_ROOM2,
+        ),
     ),
     DemoRow(
       label = "Room 3",
@@ -161,6 +216,7 @@ private val DEMO_ROWS =
           displayInfo = DRIVER_ROOM3,
         ),
       openHelper = null, // Room 3 only runs on the SQLiteDriver path.
+      bridge = null,
     ),
     DemoRow(
       label = "SQLDelight",
@@ -172,6 +228,7 @@ private val DEMO_ROWS =
           op = "db.sql.openhelper-sqldelight",
           displayInfo = OPENHELPER_SQLDELIGHT,
         ),
+      bridge = null,
     ),
   )
 
@@ -187,6 +244,7 @@ private val DEMO_ROWS =
 class SQLiteActivity : ComponentActivity() {
 
   private var latestResult by mutableStateOf("")
+  private var warmUpErrors by mutableStateOf("")
   private var sqlDetail by mutableStateOf(SQL_DETAIL_HINT)
   private var heavyWork by mutableStateOf(false)
 
@@ -198,8 +256,8 @@ class SQLiteActivity : ComponentActivity() {
    */
   private var shareScreenTrace by mutableStateOf(false)
 
-  /** Which integration the demo buttons target. Switching it disables the rows that don't apply. */
-  private var integration by mutableStateOf(Integration.DRIVER)
+  /** Which integration is currently being demoed. Switching it disables rows that don't apply. */
+  private var integration by mutableStateOf(IntegrationMode.DRIVER)
 
   /** Incremented on each tap that runs SQL. Used to retrigger the detail box's outline shimmer. */
   private var runTick by mutableStateOf(0)
@@ -265,31 +323,19 @@ class SQLiteActivity : ComponentActivity() {
 
             SectionHeader("Configure it")
 
-            val openHelper = integration == Integration.OPEN_HELPER
-            val integrationSwitchColors =
-              SwitchDefaults.colors(
-                checkedTrackColor = SentryPink,
-                checkedBorderColor = SentryPink,
-                uncheckedTrackColor = SentryPurple,
-                uncheckedBorderColor = SentryPurple,
-                uncheckedThumbColor = Color.White,
-              )
             val controlSwitchColors =
               SwitchDefaults.colors(
                 checkedTrackColor = Color.Black,
                 checkedBorderColor = Color.Black,
               )
-            ToggleRow(
-              label = if (openHelper) "SentrySupportSQLiteOpenHelper" else "SentrySQLiteDriver",
-              checked = openHelper,
-              labelColor = if (openHelper) SentryPink else SentryPurple,
-              switchColors = integrationSwitchColors,
-            ) {
-              integration = if (it) Integration.OPEN_HELPER else Integration.DRIVER
-              // Switching integration starts a fresh comparison: clear the detail box and result.
-              sqlDetail = SQL_DETAIL_HINT
-              latestResult = ""
-            }
+            IntegrationModeSelector(
+              selected = integration,
+              onSelected = {
+                integration = it
+                sqlDetail = SQL_DETAIL_HINT
+                latestResult = ""
+              },
+            )
             ToggleRow(
               label = if (heavyWork) "Heavy app-level work" else "No app-level work",
               checked = heavyWork,
@@ -313,12 +359,12 @@ class SQLiteActivity : ComponentActivity() {
             // integration's variant; a row that doesn't apply explains why via a toast (see
             // [DemoRowButton]).
             DEMO_ROWS.forEach { row ->
-              val variant = if (integration == Integration.DRIVER) row.driver else row.openHelper
+              val variant = row.variantFor(integration)
               DemoRowButton(
                 label = row.label,
                 color = integration.color,
                 variant = variant,
-                disabledReason = "${row.label} doesn't use the ${integration.apiName}",
+                disabledReason = "${row.label} doesn't support the ${integration.apiName} stack",
               )
             }
 
@@ -330,12 +376,26 @@ class SQLiteActivity : ComponentActivity() {
             // Same [CONTROL_SECTION_GAP] above as the other sections, separating the controls from
             // the detail output.
             SectionHeader("Under the hood", topPadding = CONTROL_SECTION_GAP)
+            LaunchedEffect(Unit) {
+              while (!SampleDatabases.isWarmUpComplete()) {
+                warmUpErrors = SampleDatabases.warmUpErrors
+                delay(250)
+              }
+              warmUpErrors = SampleDatabases.warmUpErrors
+            }
+            if (warmUpErrors.isNotEmpty()) {
+              Text(
+                text = warmUpErrors,
+                style = MaterialTheme.typography.bodyMedium,
+                color = SentryRed,
+              )
+            }
             // The latest run result (row counts, errors). Hidden until the first run.
             if (latestResult.isNotEmpty()) {
               Text(
                 text = latestResult,
                 style = MaterialTheme.typography.bodyMedium,
-                color = if (latestResult.contains("failed")) SentryRed else Color.Unspecified,
+                color = if (latestResult.looksLikeError()) SentryRed else Color.Unspecified,
               )
             }
             DetailField("SQL run", sqlDetail, borderColor = detailOutline)
@@ -361,12 +421,13 @@ class SQLiteActivity : ComponentActivity() {
     lifecycleScope.launch {
       dbOperationInFlight = true
       try {
-        latestResult =
+        val result =
           withContext(Dispatchers.IO) {
             runInTransaction(variant.transactionName, variant.op) {
               SqlStatements.execute(applicationContext, variant.demo, heavyWork)
             }
           }
+        latestResult = result
       } finally {
         dbOperationInFlight = false
       }
@@ -385,9 +446,41 @@ class SQLiteActivity : ComponentActivity() {
     startActivity(UiLoadActivity.intent(this, variant.demo, heavyWork))
   }
 
+  @OptIn(ExperimentalMaterial3Api::class)
+  @androidx.compose.runtime.Composable
+  private fun IntegrationModeSelector(
+    selected: IntegrationMode,
+    onSelected: (IntegrationMode) -> Unit,
+  ) {
+    SingleChoiceSegmentedButtonRow(modifier = Modifier.fillMaxWidth()) {
+      IntegrationMode.entries.forEachIndexed { index, mode ->
+        SegmentedButton(
+          shape =
+            SegmentedButtonDefaults.itemShape(index = index, count = IntegrationMode.entries.size),
+          onClick = { onSelected(mode) },
+          selected = selected == mode,
+          icon = {},
+          colors =
+            SegmentedButtonDefaults.colors(
+              activeContainerColor = mode.color,
+              activeContentColor = Color.White,
+            ),
+          label = { Text(mode.segmentLabel, style = MaterialTheme.typography.labelSmall) },
+        )
+      }
+    }
+
+    Text(
+      text = selected.subtitle,
+      style = MaterialTheme.typography.bodySmall,
+      color = Color.Gray,
+      modifier = Modifier.padding(top = 6.dp),
+    )
+  }
+
   /**
    * A compact, left-justified labeled switch. [labelColor] defaults to [Color.Unspecified] so the
-   * label inherits the default text color; the integration toggle passes its pink/purple instead.
+   * label inherits the default text color.
    */
   @androidx.compose.runtime.Composable
   private fun ToggleRow(
@@ -533,7 +626,11 @@ class SQLiteActivity : ComponentActivity() {
           try {
             val message = withContext(Dispatchers.IO) { resetDatabases() }
             latestResult = message
+            warmUpErrors = SampleDatabases.warmUpErrors
             sqlDetail = "DROP: deletes every demo database file, resetting all row counts to 0."
+          } catch (t: Throwable) {
+            Log.e(TAG, "Reset failed", t)
+            latestResult = "Reset failed: ${t.message ?: t.javaClass.simpleName}"
           } finally {
             this@SQLiteActivity.dbOperationInFlight = false
             this@SQLiteActivity.resetInProgress = false
@@ -595,7 +692,8 @@ class SQLiteActivity : ComponentActivity() {
       result
     } catch (t: Throwable) {
       transaction.status = SpanStatus.INTERNAL_ERROR
-      "$transactionName failed: ${t.message}"
+      Log.e(TAG, "$transactionName failed", t)
+      "$transactionName failed: ${t.message ?: t.javaClass.simpleName}"
     } finally {
       transaction.finish()
     }
@@ -604,11 +702,20 @@ class SQLiteActivity : ComponentActivity() {
   /** Closes + deletes every demo database file (via [SampleDatabases]), then re-warms them. */
   private suspend fun resetDatabases(): String {
     val cleared = SampleDatabases.reset(applicationContext)
-    return "Dropped tables: cleared $cleared database file(s)."
+    SampleDatabases.awaitWarmUp()
+    return buildString {
+      append("Dropped tables: cleared $cleared database file(s).")
+      if (SampleDatabases.warmUpErrors.isNotEmpty()) {
+        append("\n\n")
+        append(SampleDatabases.warmUpErrors)
+      }
+    }
   }
 
   private companion object {
 
+    private const val TAG = "SQLiteActivity"
+
     /** Demo SQL shorter than this won't visibly disable the reset button. */
     private const val RESET_DISABLE_DEBOUNCE_MS = 300L
 
@@ -619,3 +726,5 @@ class SQLiteActivity : ComponentActivity() {
     private fun newScreenTrace(): String = "${SentryId()}-${SpanId()}-1"
   }
 }
+
+private fun String.looksLikeError(): Boolean = contains("failed", ignoreCase = true)
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt
index 63f217fcfbb..19b292cd91e 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt
@@ -1,12 +1,14 @@
 package io.sentry.samples.android.sqlite
 
 import android.content.Context
+import android.util.Log
 import androidx.room.Room
 import androidx.room3.Room as Room3
 import androidx.sqlite.SQLiteConnection
 import androidx.sqlite.db.SupportSQLiteDatabase
 import androidx.sqlite.db.SupportSQLiteOpenHelper
 import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory
+import androidx.sqlite.driver.SupportSQLiteDriver
 import androidx.sqlite.driver.bundled.BundledSQLiteDriver
 import androidx.sqlite.execSQL
 import app.cash.sqldelight.driver.android.AndroidSqliteDriver
@@ -18,6 +20,7 @@ import io.sentry.samples.android.sqlite.SampleDatabases.warmUp
 import io.sentry.sqlite.SentrySQLiteDriver
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
@@ -42,18 +45,40 @@ import kotlinx.coroutines.sync.withLock
  */
 object SampleDatabases {
 
+  private const val TAG = "SampleDatabases"
+
+  /** Non-empty when one or more warm-up steps failed; shown on [SQLiteActivity]. */
+  @Volatile
+  var warmUpErrors: String = ""
+    private set
+
+  @Volatile private var warmUpComplete = false
+  @Volatile private var warmUpGeneration = 0
+  @Volatile private var warmUpJob: Job? = null
+
+  fun isWarmUpComplete(): Boolean = warmUpComplete
+
+  /** Blocks until the in-flight [warmUp] job (if any) finishes. */
+  suspend fun awaitWarmUp() {
+    warmUpJob?.join()
+  }
+
   private val sqlAccess = Mutex()
 
   val driverDirectLock = Any()
+  val bridgeDirectLock = Any()
   val openHelperDirectLock = Any()
 
   /** Serializes demo SQL and [reset] so handles are never closed mid-statement. */
   suspend fun <T> withSqlAccess(block: suspend () -> T): T = sqlAccess.withLock { block() }
 
   @Volatile private var driverConnection: SQLiteConnection? = null
+  @Volatile private var bridgeConnection: SQLiteConnection? = null
   @Volatile private var driverRoom2Db: SampleRoom2Database? = null
+  @Volatile private var bridgeRoom2Db: SampleRoom2Database? = null
   @Volatile private var driverRoom3Db: SampleRoom3Database? = null
   @Volatile private var directHelper: SupportSQLiteOpenHelper? = null
+  @Volatile private var bridgeDirectHelper: SupportSQLiteOpenHelper? = null
   @Volatile private var openHelperRoomDb: SampleRoom2Database? = null
   @Volatile private var sqlDelightDriver: AndroidSqliteDriver? = null
 
@@ -68,6 +93,45 @@ object SampleDatabases {
           }
     }
 
+  /**
+   * The Room 2.7+ duplicate-span scenario: a Sentry-wrapped open helper bridged to
+   * [SupportSQLiteDriver], then passed to [SentrySQLiteDriver.create] (which no-ops on the bridge).
+   */
+  fun bridgeConnection(context: Context): SQLiteConnection =
+    synchronized(bridgeDirectLock) {
+      bridgeConnection
+        ?: run {
+          // SupportSQLiteDriver.open() requires fileName to match the helper's databaseName();
+          // use the absolute path Room and the direct driver path both pass to open().
+          val dbPath = databaseFile(context, "bridge_direct.db")
+          SentrySQLiteDriver.create(SupportSQLiteDriver(buildBridgeDirectHelper(context, dbPath)))
+            .open(dbPath)
+            .also {
+              it.execSQL(SqlStatements.CREATE_SONG)
+              bridgeConnection = it
+            }
+        }
+    }
+
+  fun bridgeRoom2Db(context: Context): SampleRoom2Database =
+    synchronized(this) {
+      bridgeRoom2Db
+        ?: Room.databaseBuilder(
+            context.applicationContext,
+            SampleRoom2Database::class.java,
+            "bridge_room2.db",
+          )
+          .setDriver(
+            SentrySQLiteDriver.create(
+              SupportSQLiteDriver(buildBridgeRoom2Helper(context.applicationContext))
+            )
+          )
+          .setQueryCoroutineContext(Dispatchers.IO)
+          .fallbackToDestructiveMigration(true)
+          .build()
+          .also { bridgeRoom2Db = it }
+    }
+
   fun driverRoom2Db(context: Context): SampleRoom2Database =
     synchronized(this) {
       driverRoom2Db
@@ -133,10 +197,50 @@ object SampleDatabases {
           .also { sqlDelightDriver = it }
     }
 
-  private fun buildDirectHelper(context: Context): SupportSQLiteOpenHelper {
+  private fun buildDirectHelper(context: Context): SupportSQLiteOpenHelper =
+    buildSentryHelper(context, "openhelper_direct.db").also { directHelper = it }
+
+  private fun buildBridgeDirectHelper(context: Context, dbPath: String): SupportSQLiteOpenHelper =
+    buildSentryHelper(context, dbPath).also { bridgeDirectHelper = it }
+
+  /**
+   * Open helper for the Bridge + Room 2 stack. Must not create tables in [onCreate] — Room owns the
+   * schema when [setDriver] is used. Room also passes [SupportSQLiteOpenHelper.databaseName] (the
+   * short name below), not an absolute path, to [SupportSQLiteDriver.open].
+   *
+   * The callback version must be 1 (FrameworkSQLiteOpenHelper rejects &lt; 1). That sets `PRAGMA
+   * user_version = 1` before Room opens, so Room would skip [onCreate] and validate the empty file
+   * as pre-packaged → "invalid schema". [onOpen] clears user_version back to 0 until
+   * [ROOM_MASTER_TABLE] exists.
+   */
+  private fun buildBridgeRoom2Helper(context: Context): SupportSQLiteOpenHelper {
     val configuration =
       SupportSQLiteOpenHelper.Configuration.builder(context.applicationContext)
-        .name("openhelper_direct.db")
+        .name("bridge_room2.db")
+        .callback(
+          object : SupportSQLiteOpenHelper.Callback(1) {
+            override fun onCreate(db: SupportSQLiteDatabase) = Unit
+
+            override fun onUpgrade(db: SupportSQLiteDatabase, oldVersion: Int, newVersion: Int) =
+              Unit
+
+            override fun onOpen(db: SupportSQLiteDatabase) {
+              if (!db.hasRoomMasterTable()) {
+                db.execSQL("PRAGMA user_version = 0")
+              }
+            }
+          }
+        )
+        .build()
+    return SentrySupportSQLiteOpenHelper.create(
+      FrameworkSQLiteOpenHelperFactory().create(configuration)
+    )
+  }
+
+  private fun buildSentryHelper(context: Context, dbName: String): SupportSQLiteOpenHelper {
+    val configuration =
+      SupportSQLiteOpenHelper.Configuration.builder(context.applicationContext)
+        .name(dbName)
         .callback(
           object : SupportSQLiteOpenHelper.Callback(1) {
             override fun onCreate(db: SupportSQLiteDatabase) {
@@ -156,22 +260,50 @@ object SampleDatabases {
   /** Opens every database on a background thread, forcing the one-time open + bootstrap to run. */
   fun warmUp(context: Context) {
     val appContext = context.applicationContext
+    val generation = ++warmUpGeneration
+    warmUpComplete = false
+    warmUpErrors = ""
     // Fire-and-forget: the warm-up outlives no particular screen, so a bare scope is fine here.
-    CoroutineScope(Dispatchers.IO).launch {
-      runCatching { driverConnection(appContext) }
-      // primeWriter() + count() opens both Room pool connections (writer + reader), so the first
-      // demo INSERT/SELECT reuses them instead of bootstrapping a connection inside its
-      // transaction.
-      runCatching { driverRoom2Db(appContext).songDao().also { it.primeWriter() }.count() }
-      runCatching { driverRoom3Db(appContext).songDao().also { it.primeWriter() }.count() }
-      runCatching { directHelper(appContext).writableDatabase }
-      runCatching { openHelperRoomDb(appContext).songDao().also { it.primeWriter() }.count() }
-      runCatching {
-        SampleSQLDelightDatabase(sqlDelightDriver(appContext))
-          .songQueries
-          .countSongs()
-          .executeAsOne()
+    warmUpJob =
+      CoroutineScope(Dispatchers.IO).launch {
+        val failures = mutableListOf<String>()
+        runWarmUpStep("driver direct", failures) { driverConnection(appContext) }
+        runWarmUpStep("bridge direct", failures) { bridgeConnection(appContext) }
+        // primeWriter() + count() opens both Room pool connections (writer + reader), so the first
+        // demo INSERT/SELECT reuses them instead of bootstrapping a connection inside its
+        // transaction.
+        runWarmUpStep("driver Room 2", failures) {
+          driverRoom2Db(appContext).songDao().also { it.primeWriter() }.count()
+        }
+        runWarmUpStep("bridge Room 2", failures) {
+          bridgeRoom2Db(appContext).songDao().also { it.primeWriter() }.count()
+        }
+        runWarmUpStep("driver Room 3", failures) {
+          driverRoom3Db(appContext).songDao().also { it.primeWriter() }.count()
+        }
+        runWarmUpStep("open helper direct", failures) { directHelper(appContext).writableDatabase }
+        runWarmUpStep("open helper Room", failures) {
+          openHelperRoomDb(appContext).songDao().also { it.primeWriter() }.count()
+        }
+        runWarmUpStep("SQLDelight", failures) {
+          SampleSQLDelightDatabase(sqlDelightDriver(appContext))
+            .songQueries
+            .countSongs()
+            .executeAsOne()
+        }
+        if (generation == warmUpGeneration) {
+          warmUpErrors = failures.joinToString("\n") { "Warm-up failed: $it" }
+          warmUpComplete = true
+        }
       }
+  }
+
+  private inline fun runWarmUpStep(step: String, failures: MutableList<String>, block: () -> Unit) {
+    try {
+      block()
+    } catch (t: Throwable) {
+      Log.e(TAG, "Warm-up failed: $step", t)
+      failures.add("$step: ${t.message ?: t.javaClass.simpleName}")
     }
   }
 
@@ -185,7 +317,9 @@ object SampleDatabases {
     val names =
       listOf(
         "driver_direct.db",
+        "bridge_direct.db",
         "driver_room2.db",
+        "bridge_room2.db",
         "driver_room3.db",
         "openhelper_direct.db",
         "openhelper_room.db",
@@ -201,6 +335,12 @@ object SampleDatabases {
       driverConnection?.close()
       driverConnection = null
     }
+    synchronized(bridgeDirectLock) {
+      bridgeConnection?.close()
+      bridgeConnection = null
+      bridgeDirectHelper?.close()
+      bridgeDirectHelper = null
+    }
     synchronized(openHelperDirectLock) {
       directHelper?.close()
       directHelper = null
@@ -208,6 +348,8 @@ object SampleDatabases {
     synchronized(this) {
       driverRoom2Db?.close()
       driverRoom2Db = null
+      bridgeRoom2Db?.close()
+      bridgeRoom2Db = null
       driverRoom3Db?.close()
       driverRoom3Db = null
       openHelperRoomDb?.close()
@@ -219,4 +361,11 @@ object SampleDatabases {
 
   private fun databaseFile(context: Context, name: String): String =
     context.applicationContext.getDatabasePath(name).also { it.parentFile?.mkdirs() }.absolutePath
+
+  private fun SupportSQLiteDatabase.hasRoomMasterTable(): Boolean =
+    query("SELECT 1 FROM sqlite_master WHERE name = '$ROOM_MASTER_TABLE' LIMIT 1").use {
+      it.moveToFirst()
+    }
 }
+
+private const val ROOM_MASTER_TABLE = "room_master_table"
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SqlStatements.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SqlStatements.kt
index 543f1169294..9bd2d624694 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SqlStatements.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SqlStatements.kt
@@ -18,6 +18,8 @@ enum class SqlDemo {
   DRIVER_DIRECT,
   DRIVER_ROOM2,
   DRIVER_ROOM3,
+  BRIDGE_DIRECT,
+  BRIDGE_ROOM2,
   OPENHELPER_DIRECT,
   OPENHELPER_ROOM,
   OPENHELPER_SQLDELIGHT,
@@ -64,6 +66,8 @@ object SqlStatements {
         SqlDemo.DRIVER_DIRECT -> driverDirect(context, heavy)
         SqlDemo.DRIVER_ROOM2 -> driverWithRoom2(context, heavy)
         SqlDemo.DRIVER_ROOM3 -> driverWithRoom3(context, heavy)
+        SqlDemo.BRIDGE_DIRECT -> bridgeDirect(context, heavy)
+        SqlDemo.BRIDGE_ROOM2 -> bridgeWithRoom2(context, heavy)
         SqlDemo.OPENHELPER_DIRECT -> openHelperDirect(context, heavy)
         SqlDemo.OPENHELPER_ROOM -> openHelperWithRoom(context, heavy)
         SqlDemo.OPENHELPER_SQLDELIGHT -> openHelperWithSqlDelight(context, heavy)
@@ -115,6 +119,37 @@ object SqlStatements {
       if (statement.step()) statement.getLong(0) else 0
     }
 
+  // --- 1b. SupportSQLiteDriver bridge (helper + driver both wrapped; SDK skips driver wrap) --
+
+  private fun bridgeDirect(context: Context, heavy: Boolean): String =
+    synchronized(SampleDatabases.bridgeDirectLock) {
+      val connection = SampleDatabases.bridgeConnection(context)
+      insert(connection, "Mishima / Closing", "Philip Glass")
+      insert(connection, "School of Velocity, op 299 no 1, ", "Carl Czerny")
+
+      if (heavy) {
+        connection.prepare(insertSongsBatch(HEAVY_ROW_COUNT)).use { statement ->
+          var param = 1
+          repeat(HEAVY_ROW_COUNT) { row ->
+            statement.bindText(param++, "song $row")
+            statement.bindText(param++, "artist $row")
+          }
+          statement.step()
+        }
+
+        connection.prepare(SELECT_SONGS).use { statement ->
+          while (statement.step()) {
+            val row = "${statement.getLong(0)}:${statement.getText(1)}:${statement.getText(2)}"
+            appWork(row)
+          }
+        }
+      }
+      "Bridge (Direct): ${count(connection)} rows."
+    }
+
+  private suspend fun bridgeWithRoom2(context: Context, heavy: Boolean): String =
+    roomDemo(SampleDatabases.bridgeRoom2Db(context).songDao(), "Bridge (Room 2)", heavy)
+
   // --- 2. SentrySQLiteDriver, used through Room 2.7+ ----------------------------------------
 
   private suspend fun driverWithRoom2(context: Context, heavy: Boolean): String =
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadActivity.kt
index b32811e8c91..3cc6d394daa 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/UiLoadActivity.kt
@@ -3,6 +3,7 @@ package io.sentry.samples.android.sqlite
 import android.content.Context
 import android.content.Intent
 import android.os.Bundle
+import android.util.Log
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.compose.runtime.getValue
@@ -48,7 +49,8 @@ class UiLoadActivity : ComponentActivity() {
             withContext(Dispatchers.IO) { SqlStatements.execute(applicationContext, id, heavy) }
           "$result\n\nRan under the auto ui.load transaction."
         } catch (t: Throwable) {
-          "Load failed: ${t.message}"
+          Log.e(TAG, "Load failed", t)
+          "Load failed: ${t.message ?: t.javaClass.simpleName}"
         } finally {
           // Close the TTFD window so the ui.load transaction finishes with the db spans attached.
           Sentry.reportFullyDisplayed()
@@ -57,6 +59,7 @@ class UiLoadActivity : ComponentActivity() {
   }
 
   companion object {
+    private const val TAG = "UiLoadActivity"
     private const val EXTRA_DEMO_ID = "demo_id"
     private const val EXTRA_HEAVY = "heavy"
 

From 547d3e463dec24c1b99586f85e0cd5f2d73b9022 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 19 Jun 2026 10:04:12 +0200
Subject: [PATCH 215/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.15.1 (#5570)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 ++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8428f033b78..76b2d974e5a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,12 @@
   - To use it, pass `SQLiteDriver` to `SentrySQLiteDriver.create(...)`
   - Requires `androidx.sqlite:sqlite` (2.5.0+) on runtime classpath (typically provided by Room or SQLDelight)
 
+### Dependencies
+
+- Bump Native SDK from v0.15.0 to v0.15.1 ([#5570](https://github.com/getsentry/sentry-java/pull/5570))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0151)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.15.0...0.15.1)
+
 ## 8.44.0
 
 ### Features
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 91a7669194f..68521efdfcc 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -166,7 +166,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.0" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.1" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 9c501bbbe56976ba47b467455062992eac005b07 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 19 Jun 2026 08:07:08 +0000
Subject: [PATCH 216/391] chore(deps): bump actions/checkout in the
 github-actions group (#5569)

Bumps the github-actions group with 1 update: [actions/checkout](https://github.com/actions/checkout).


Updates `actions/checkout` from 6.0.3 to 7.0.0
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/df4cb1c069e1874edd31b4311f1884172cec0e10...9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: 7.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/changes-in-high-risk-code.yml     | 2 +-
 .github/workflows/check-tombstone-proto-schema.yml  | 2 +-
 .github/workflows/codeql-analysis.yml               | 2 +-
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 4 ++--
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/release.yml                       | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 18 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 40f8509fee4..8ddb961ec96 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -28,7 +28,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 375e94e7499..f2ffd96f9c5 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -19,7 +19,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           ref: ${{ github.event.pull_request.head.sha || github.sha }}
           submodules: 'recursive'
diff --git a/.github/workflows/changes-in-high-risk-code.yml b/.github/workflows/changes-in-high-risk-code.yml
index 028b4217ef2..78918167207 100644
--- a/.github/workflows/changes-in-high-risk-code.yml
+++ b/.github/workflows/changes-in-high-risk-code.yml
@@ -16,7 +16,7 @@ jobs:
       high_risk_code: ${{ steps.changes.outputs.high_risk_code }}
       high_risk_code_files: ${{ steps.changes.outputs.high_risk_code_files }}
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Get changed files
         id: changes
         uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
diff --git a/.github/workflows/check-tombstone-proto-schema.yml b/.github/workflows/check-tombstone-proto-schema.yml
index 535b2170fae..3e30f97e45e 100644
--- a/.github/workflows/check-tombstone-proto-schema.yml
+++ b/.github/workflows/check-tombstone-proto-schema.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Check for newer Tombstone proto schema
         run: ./scripts/check-tombstone-proto-schema.sh
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index e24b7c96c14..ccc9cc04a85 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index e5e4530933b..38680fe0a23 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -20,7 +20,7 @@ jobs:
           java-version: '17'
 
       - name: Checkout
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       # TODO: remove this when upstream is fixed
       - name: Disable Gradle configuration cache (see https://github.com/fossas/fossa-cli/issues/872)
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index ec427af3564..2892df16701 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index 2e82024077a..fabd36736aa 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout 🛎️
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 4d323f0394a..45b063705dc 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -27,7 +27,7 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
@@ -77,7 +77,7 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index e2fa42ddc16..5c212d5895a 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Setup Java Version
         uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 18809c060e1..7d0b74b4329 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -27,7 +27,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Set up Java 17
         uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
@@ -77,7 +77,7 @@ jobs:
             arch: x86_64
     steps:
       - name: Checkout code
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Enable KVM
         run: |
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index f7b95a26d12..92e29ecbef7 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -22,7 +22,7 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 9fecaf32b5e..050782006f0 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -15,7 +15,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index eddeaa24cd9..dd266d948c2 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -27,7 +27,7 @@ jobs:
         with:
           app-id: ${{ vars.SENTRY_RELEASE_BOT_CLIENT_ID }}
           private-key: ${{ secrets.SENTRY_RELEASE_BOT_PRIVATE_KEY }}
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           token: ${{ steps.token.outputs.token }}
           # Needs to be set, otherwise git describe --tags will fail with: No names found, cannot describe anything
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 7628a0bbba0..6e0b1366c9f 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 40670eaf258..00e93f5442b 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 128051ed03e..450dbd8c98d 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 62a1b7665c0..67f81f2fb64 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -98,7 +98,7 @@ jobs:
             agent: "false"
             agent-auto-init: "true"
     steps:
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           submodules: 'recursive'
 

From 8da852cc8e39d8246ba5a712c88d38b64618b074 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Fri, 19 Jun 2026 11:11:14 +0200
Subject: [PATCH 217/391] fix(android): Make FirstDrawDoneListener cleanup
 OnGlobalLayoutListener after use (#5567)

* fix(android): Make FirstDrawDoneListener cleanup OnGlobalLayoutListener after use

The OnGlobalLayoutListener registered in onDraw() to defer removal of the
OnDrawListener was never itself removed. In single-Activity apps (e.g. React
Native), this caused an unbounded per-navigation leak on the ViewTreeObserver,
accumulating one listener per registerForNextDraw call.

Make the OnGlobalLayoutListener remove itself after firing.

Fixes JAVA-545
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  4 +++
 .../internal/util/FirstDrawDoneListener.java  |  9 +++++-
 .../util/FirstDrawDoneListenerTest.kt         | 31 +++++++++++++++++++
 3 files changed, 43 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 76b2d974e5a..395b1f2e2b1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+
+- Fix `FirstDrawDoneListener` leaking an `OnGlobalLayoutListener` per registration ([#5567](https://github.com/getsentry/sentry-java/pull/5567))
+
 ### Features
 
 - Add experimental `SentrySQLiteDriver` to `sentry-android-sqlite` for instrumenting `androidx.sqlite.SQLiteDriver` ([#5563](https://github.com/getsentry/sentry-java/pull/5563))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/FirstDrawDoneListener.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/FirstDrawDoneListener.java
index f2612b4aa84..0629b7a4908 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/FirstDrawDoneListener.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/FirstDrawDoneListener.java
@@ -112,7 +112,14 @@ public void onDraw() {
     // OnDrawListeners cannot be removed within onDraw, so we remove it with a
     // GlobalLayoutListener
     view.getViewTreeObserver()
-        .addOnGlobalLayoutListener(() -> view.getViewTreeObserver().removeOnDrawListener(this));
+        .addOnGlobalLayoutListener(
+            new ViewTreeObserver.OnGlobalLayoutListener() {
+              @Override
+              public void onGlobalLayout() {
+                view.getViewTreeObserver().removeOnGlobalLayoutListener(this);
+                view.getViewTreeObserver().removeOnDrawListener(FirstDrawDoneListener.this);
+              }
+            });
     mainThreadHandler.postAtFrontOfQueue(callback);
   }
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/FirstDrawDoneListenerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/FirstDrawDoneListenerTest.kt
index 008a036cbfc..44d6d9fd03a 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/FirstDrawDoneListenerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/FirstDrawDoneListenerTest.kt
@@ -128,6 +128,37 @@ class FirstDrawDoneListenerTest {
     assertTrue(fixture.onDrawListeners.isEmpty())
   }
 
+  @Test
+  fun `OnGlobalLayoutListener is removed after cleanup`() {
+    val view = fixture.getSut()
+
+    // Initialize mOnGlobalLayoutListeners via a dummy add/remove
+    val dummyGlobalListener = ViewTreeObserver.OnGlobalLayoutListener {}
+    view.viewTreeObserver.addOnGlobalLayoutListener(dummyGlobalListener)
+    view.viewTreeObserver.removeOnGlobalLayoutListener(dummyGlobalListener)
+
+    // CopyOnWriteArray wraps an internal ArrayList called mData
+    val copyOnWriteArray: Any = view.viewTreeObserver.getProperty("mOnGlobalLayoutListeners")
+    val mDataField = copyOnWriteArray.javaClass.getDeclaredField("mData")
+    mDataField.isAccessible = true
+
+    @Suppress("UNCHECKED_CAST")
+    fun globalLayoutListeners(): ArrayList<*> = mDataField.get(copyOnWriteArray) as ArrayList<*>
+
+    assertTrue(globalLayoutListeners().isEmpty())
+
+    FirstDrawDoneListener.registerForNextDraw(view, {}, fixture.buildInfo)
+
+    // onDraw registers a cleanup OnGlobalLayoutListener
+    view.viewTreeObserver.dispatchOnDraw()
+    assertFalse(globalLayoutListeners().isEmpty())
+
+    // onGlobalLayout fires the cleanup, which removes both the draw and layout listeners
+    view.viewTreeObserver.dispatchOnGlobalLayout()
+    assertTrue(globalLayoutListeners().isEmpty())
+    assertTrue(fixture.onDrawListeners.isEmpty())
+  }
+
   @Test
   fun `registerForNextDraw calls the given callback on the main thread after onDraw`() {
     val view = fixture.getSut()

From f4269fd1cb8cbeef665b2e1316819fc632e2e338 Mon Sep 17 00:00:00 2001
From: runningcode <332597+runningcode@users.noreply.github.com>
Date: Fri, 19 Jun 2026 12:51:59 +0000
Subject: [PATCH 218/391] release: 8.44.1

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 395b1f2e2b1..b3bdcd38bc4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.44.1
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index 19127ac9832..f2e3da3ca09 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.44.0
+versionName=8.44.1
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 69943b840653f4dde405bdc32c4fde5732dcc43f Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Fri, 19 Jun 2026 16:00:18 +0200
Subject: [PATCH 219/391] refactor(android-sqlite): Rename classes
 instrumenting SQLite spans for consistency (#5555)

---
 ...QLiteSpanManager.kt => OpenHelperSpans.kt} |  3 +-
 .../sqlite/SentryCrossProcessCursor.kt        |  8 +--
 .../sqlite/SentrySupportSQLiteDatabase.kt     | 21 ++++---
 .../sqlite/SentrySupportSQLiteOpenHelper.kt   |  6 +-
 .../sqlite/SentrySupportSQLiteStatement.kt    | 17 +++---
 ...eSpanInstrumentation.kt => DriverSpans.kt} | 26 ++++-----
 .../sentry/sqlite/SentrySQLiteConnection.kt   |  2 +-
 .../io/sentry/sqlite/SentrySQLiteDriver.kt    |  2 +-
 .../io/sentry/sqlite/SentrySQLiteStatement.kt |  4 +-
 ...nManagerTest.kt => OpenHelperSpansTest.kt} |  6 +-
 .../sqlite/SentryCrossProcessCursorTest.kt    |  4 +-
 .../sqlite/SentrySupportSQLiteDatabaseTest.kt |  4 +-
 .../SentrySupportSQLiteStatementTest.kt       |  4 +-
 ...trumentationTest.kt => DriverSpansTest.kt} | 55 +++++++++----------
 .../sqlite/SentrySQLiteConnectionTest.kt      |  4 +-
 .../sqlite/SentrySQLiteStatementTest.kt       | 10 ++--
 16 files changed, 82 insertions(+), 94 deletions(-)
 rename sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/{SQLiteSpanManager.kt => OpenHelperSpans.kt} (96%)
 rename sentry-android-sqlite/src/main/java/io/sentry/sqlite/{SQLiteSpanInstrumentation.kt => DriverSpans.kt} (81%)
 rename sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/{SQLiteSpanManagerTest.kt => OpenHelperSpansTest.kt} (97%)
 rename sentry-android-sqlite/src/test/java/io/sentry/sqlite/{SQLiteSpanInstrumentationTest.kt => DriverSpansTest.kt} (77%)

diff --git a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/OpenHelperSpans.kt
similarity index 96%
rename from sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt
rename to sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/OpenHelperSpans.kt
index 1bdeb7d369c..059eb1bb1b5 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SQLiteSpanManager.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/OpenHelperSpans.kt
@@ -13,7 +13,8 @@ import io.sentry.SpanStatus
 
 private const val TRACE_ORIGIN = "auto.db.sqlite"
 
-internal class SQLiteSpanManager(
+/** Span instrumentation for [SentrySupportSQLiteOpenHelper]. */
+internal class OpenHelperSpans(
   private val scopes: IScopes = ScopesAdapter.getInstance(),
   private val databaseName: String? = null,
 ) {
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentryCrossProcessCursor.kt b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentryCrossProcessCursor.kt
index 1f3796a8975..f5f8424aca3 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentryCrossProcessCursor.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentryCrossProcessCursor.kt
@@ -13,7 +13,7 @@ import android.database.CursorWindow
  */
 internal class SentryCrossProcessCursor(
   private val delegate: CrossProcessCursor,
-  private val spanManager: SQLiteSpanManager,
+  private val spans: OpenHelperSpans,
   private val sql: String,
 ) : CrossProcessCursor by delegate {
   // We have to start the span only the first time, regardless of how many times its methods get
@@ -25,7 +25,7 @@ internal class SentryCrossProcessCursor(
       return delegate.count
     }
     isSpanStarted = true
-    return spanManager.performSql(sql) { delegate.count }
+    return spans.performSql(sql) { delegate.count }
   }
 
   override fun onMove(oldPosition: Int, newPosition: Int): Boolean {
@@ -33,7 +33,7 @@ internal class SentryCrossProcessCursor(
       return delegate.onMove(oldPosition, newPosition)
     }
     isSpanStarted = true
-    return spanManager.performSql(sql) { delegate.onMove(oldPosition, newPosition) }
+    return spans.performSql(sql) { delegate.onMove(oldPosition, newPosition) }
   }
 
   override fun fillWindow(position: Int, window: CursorWindow?) {
@@ -41,6 +41,6 @@ internal class SentryCrossProcessCursor(
       return delegate.fillWindow(position, window)
     }
     isSpanStarted = true
-    return spanManager.performSql(sql) { delegate.fillWindow(position, window) }
+    return spans.performSql(sql) { delegate.fillWindow(position, window) }
   }
 }
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteDatabase.kt b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteDatabase.kt
index bfe3265f89b..458203a232f 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteDatabase.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteDatabase.kt
@@ -14,11 +14,11 @@ import androidx.sqlite.db.SupportSQLiteStatement
  * and it's created automatically by the [SentrySupportSQLiteOpenHelper].
  *
  * @param delegate The [SupportSQLiteDatabase] instance to delegate calls to.
- * @param sqLiteSpanManager The [SQLiteSpanManager] responsible for the creation of the spans.
+ * @param spans The [OpenHelperSpans] manager responsible for the creation of the spans.
  */
 internal class SentrySupportSQLiteDatabase(
   private val delegate: SupportSQLiteDatabase,
-  private val sqLiteSpanManager: SQLiteSpanManager,
+  private val spans: OpenHelperSpans,
 ) : SupportSQLiteDatabase by delegate {
   /**
    * Compiles the given SQL statement. It will return Sentry's wrapper around
@@ -28,35 +28,34 @@ internal class SentrySupportSQLiteDatabase(
    * @return Compiled statement.
    */
   override fun compileStatement(sql: String): SupportSQLiteStatement =
-    SentrySupportSQLiteStatement(delegate.compileStatement(sql), sqLiteSpanManager, sql)
+    SentrySupportSQLiteStatement(delegate.compileStatement(sql), spans, sql)
 
   @Suppress("AcronymName") // To keep consistency with framework method name.
   override fun execPerConnectionSQL(
     sql: String,
     @SuppressLint("ArrayReturn") bindArgs: Array<out Any?>?,
   ) {
-    sqLiteSpanManager.performSql(sql) { delegate.execPerConnectionSQL(sql, bindArgs) }
+    spans.performSql(sql) { delegate.execPerConnectionSQL(sql, bindArgs) }
   }
 
-  override fun query(query: String): Cursor =
-    sqLiteSpanManager.performSql(query) { delegate.query(query) }
+  override fun query(query: String): Cursor = spans.performSql(query) { delegate.query(query) }
 
   override fun query(query: String, bindArgs: Array<out Any?>): Cursor =
-    sqLiteSpanManager.performSql(query) { delegate.query(query, bindArgs) }
+    spans.performSql(query) { delegate.query(query, bindArgs) }
 
   override fun query(query: SupportSQLiteQuery): Cursor =
-    sqLiteSpanManager.performSql(query.sql) { delegate.query(query) }
+    spans.performSql(query.sql) { delegate.query(query) }
 
   override fun query(query: SupportSQLiteQuery, cancellationSignal: CancellationSignal?): Cursor =
-    sqLiteSpanManager.performSql(query.sql) { delegate.query(query, cancellationSignal) }
+    spans.performSql(query.sql) { delegate.query(query, cancellationSignal) }
 
   @Throws(SQLException::class)
   override fun execSQL(sql: String) {
-    sqLiteSpanManager.performSql(sql) { delegate.execSQL(sql) }
+    spans.performSql(sql) { delegate.execSQL(sql) }
   }
 
   @Throws(SQLException::class)
   override fun execSQL(sql: String, bindArgs: Array<out Any?>) {
-    sqLiteSpanManager.performSql(sql) { delegate.execSQL(sql, bindArgs) }
+    spans.performSql(sql) { delegate.execSQL(sql, bindArgs) }
   }
 }
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteOpenHelper.kt b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteOpenHelper.kt
index 76b405d9f11..12b63cfa128 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteOpenHelper.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteOpenHelper.kt
@@ -33,14 +33,14 @@ import androidx.sqlite.db.SupportSQLiteOpenHelper
 public class SentrySupportSQLiteOpenHelper
 private constructor(private val delegate: SupportSQLiteOpenHelper) :
   SupportSQLiteOpenHelper by delegate {
-  private val sqLiteSpanManager = SQLiteSpanManager(databaseName = delegate.databaseName)
+  private val spans = OpenHelperSpans(databaseName = delegate.databaseName)
 
   private val sentryWritableDatabase: SupportSQLiteDatabase by lazy {
-    SentrySupportSQLiteDatabase(delegate.writableDatabase, sqLiteSpanManager)
+    SentrySupportSQLiteDatabase(delegate.writableDatabase, spans)
   }
 
   private val sentryReadableDatabase: SupportSQLiteDatabase by lazy {
-    SentrySupportSQLiteDatabase(delegate.readableDatabase, sqLiteSpanManager)
+    SentrySupportSQLiteDatabase(delegate.readableDatabase, spans)
   }
 
   override val writableDatabase: SupportSQLiteDatabase
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteStatement.kt b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteStatement.kt
index 1a364dc27ba..3df6d287b28 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteStatement.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentrySupportSQLiteStatement.kt
@@ -9,25 +9,22 @@ import androidx.sqlite.db.SupportSQLiteStatement
  * [SentrySupportSQLiteDatabase.compileStatement].
  *
  * @param delegate The [SupportSQLiteStatement] instance to delegate calls to.
- * @param sqLiteSpanManager The [SQLiteSpanManager] responsible for the creation of the spans.
+ * @param spans The [OpenHelperSpans] manager responsible for the creation of the spans.
  * @param sql The query string.
  */
 internal class SentrySupportSQLiteStatement(
   private val delegate: SupportSQLiteStatement,
-  private val sqLiteSpanManager: SQLiteSpanManager,
+  private val spans: OpenHelperSpans,
   private val sql: String,
 ) : SupportSQLiteStatement by delegate {
-  override fun execute() = sqLiteSpanManager.performSql(sql) { delegate.execute() }
+  override fun execute() = spans.performSql(sql) { delegate.execute() }
 
-  override fun executeUpdateDelete(): Int =
-    sqLiteSpanManager.performSql(sql) { delegate.executeUpdateDelete() }
+  override fun executeUpdateDelete(): Int = spans.performSql(sql) { delegate.executeUpdateDelete() }
 
-  override fun executeInsert(): Long =
-    sqLiteSpanManager.performSql(sql) { delegate.executeInsert() }
+  override fun executeInsert(): Long = spans.performSql(sql) { delegate.executeInsert() }
 
-  override fun simpleQueryForLong(): Long =
-    sqLiteSpanManager.performSql(sql) { delegate.simpleQueryForLong() }
+  override fun simpleQueryForLong(): Long = spans.performSql(sql) { delegate.simpleQueryForLong() }
 
   override fun simpleQueryForString(): String? =
-    sqLiteSpanManager.performSql(sql) { delegate.simpleQueryForString() }
+    spans.performSql(sql) { delegate.simpleQueryForString() }
 }
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/DriverSpans.kt
similarity index 81%
rename from sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
rename to sentry-android-sqlite/src/main/java/io/sentry/sqlite/DriverSpans.kt
index f0998dfdc23..b3c0eb7c713 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SQLiteSpanInstrumentation.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/DriverSpans.kt
@@ -20,20 +20,17 @@ private const val SQLITE_TRACE_ORIGIN = "auto.db.sqlite"
 private val EMPTY_NANO_TIME = SentryNanotimeDate(0, 0L)
 
 /** Span instrumentation for [SentrySQLiteDriver]. */
-internal class SQLiteSpanInstrumentation(
-  private val scopes: IScopes,
-  private val dbMetadata: DbMetadata,
-) {
+internal class DriverSpans(private val scopes: IScopes, private val dbMetadata: DbMetadata) {
 
   private val stackTraceFactory = SentryStackTraceFactory(scopes.options)
 
   /**
-   * Returns a timestamp in nanoseconds for use with [recordSpan]. Timestamp is ns-precise if the
-   * active parent span uses a [SentryNanotimeDate] (the ordinary case); otherwise it's ms-precise.
+   * Returns a timestamp in nanoseconds for use with [record]. Timestamp is ns-precise if the active
+   * parent span uses a [SentryNanotimeDate] (the ordinary case); otherwise it's ms-precise.
    *
-   * Note: Internalizing the start time in [recordSpan] would shift spans to end-of-work on the
-   * trace timeline, which is less desirable; callers capture the start before doing database work
-   * and pass it back to [recordSpan].
+   * Note: Internalizing the start time in [record] would shift spans to end-of-work on the trace
+   * timeline, which is less desirable; callers capture the start before doing database work and
+   * pass it back to [record].
    */
   fun startTimestamp(): Long =
     // Try to retain nanosecond precision + avoid SentryDate allocation...
@@ -42,7 +39,7 @@ internal class SQLiteSpanInstrumentation(
       ?: scopes.options.dateProvider.now().nanoTimestamp()
 
   /** Records a `db.sql.query` span. */
-  fun recordSpan(
+  fun record(
     sql: String,
     startTimestampNanos: Long,
     durationNanos: Long,
@@ -73,14 +70,11 @@ internal class SQLiteSpanInstrumentation(
   companion object {
 
     /**
-     * Returns [SQLiteSpanInstrumentation] based on the [fileName] argument passed to
+     * Returns [DriverSpans] based on the [fileName] argument passed to
      * [SQLiteDriver.open][androidx.sqlite.SQLiteDriver.open].
      */
-    fun fromFileName(
-      fileName: String,
-      scopes: IScopes = ScopesAdapter.getInstance(),
-    ): SQLiteSpanInstrumentation =
-      SQLiteSpanInstrumentation(scopes, dbMetadataFromFileName(fileName))
+    fun fromFileName(fileName: String, scopes: IScopes = ScopesAdapter.getInstance()): DriverSpans =
+      DriverSpans(scopes, dbMetadataFromFileName(fileName))
   }
 }
 
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteConnection.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteConnection.kt
index 45ee9a39b27..e01544b0523 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteConnection.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteConnection.kt
@@ -5,7 +5,7 @@ import androidx.sqlite.SQLiteStatement
 
 internal class SentrySQLiteConnection(
   private val delegate: SQLiteConnection,
-  private val spans: SQLiteSpanInstrumentation,
+  private val spans: DriverSpans,
 ) : SQLiteConnection by delegate {
 
   override fun prepare(sql: String): SQLiteStatement {
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
index f0f41782c22..22f6353d883 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
@@ -48,7 +48,7 @@ public class SentrySQLiteDriver private constructor(private val delegate: SQLite
     val connection = delegate.open(fileName)
 
     return try {
-      val spans = SQLiteSpanInstrumentation.fromFileName(fileName)
+      val spans = DriverSpans.fromFileName(fileName)
       // create() ensures delegate is unwrapped, so we don't need to protect against double-wrapping
       // the connection.
       SentrySQLiteConnection(connection, spans)
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt
index a739a396bcb..e220a74cd1e 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteStatement.kt
@@ -16,7 +16,7 @@ import io.sentry.SpanStatus
  */
 internal class SentrySQLiteStatement(
   private val delegate: SQLiteStatement,
-  private val spans: SQLiteSpanInstrumentation,
+  private val spans: DriverSpans,
   private val sql: String,
   private val nanoTimeProvider: () -> Long = { System.nanoTime() },
 ) : SQLiteStatement by delegate {
@@ -74,6 +74,6 @@ internal class SentrySQLiteStatement(
     val duration = accumulatedDbNanos
     firstStepTimestampNanos = null
     accumulatedDbNanos = 0L
-    spans.recordSpan(sql, startNanos, duration, status, throwable)
+    spans.record(sql, startNanos, duration, status, throwable)
   }
 }
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SQLiteSpanManagerTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/OpenHelperSpansTest.kt
similarity index 97%
rename from sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SQLiteSpanManagerTest.kt
rename to sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/OpenHelperSpansTest.kt
index 6fd6fa51bb3..0552094838e 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SQLiteSpanManagerTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/OpenHelperSpansTest.kt
@@ -21,13 +21,13 @@ import org.junit.Before
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
 
-class SQLiteSpanManagerTest {
+class OpenHelperSpansTest {
   private class Fixture {
     private val scopes = mock<IScopes>()
     lateinit var sentryTracer: SentryTracer
     lateinit var options: SentryOptions
 
-    fun getSut(isSpanActive: Boolean = true, databaseName: String? = null): SQLiteSpanManager {
+    fun getSut(isSpanActive: Boolean = true, databaseName: String? = null): OpenHelperSpans {
       options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
       whenever(scopes.options).thenReturn(options)
       sentryTracer = SentryTracer(TransactionContext("name", "op"), scopes)
@@ -35,7 +35,7 @@ class SQLiteSpanManagerTest {
       if (isSpanActive) {
         whenever(scopes.span).thenReturn(sentryTracer)
       }
-      return SQLiteSpanManager(scopes, databaseName)
+      return OpenHelperSpans(scopes, databaseName)
     }
   }
 
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentryCrossProcessCursorTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentryCrossProcessCursorTest.kt
index 44836dd0c97..27eff29c9f3 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentryCrossProcessCursorTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentryCrossProcessCursorTest.kt
@@ -20,7 +20,7 @@ import org.mockito.kotlin.whenever
 class SentryCrossProcessCursorTest {
   private class Fixture {
     private val scopes = mock<IScopes>()
-    private val spanManager = SQLiteSpanManager(scopes)
+    private val spans = OpenHelperSpans(scopes)
     val mockCursor = mock<CrossProcessCursor>()
     lateinit var options: SentryOptions
     lateinit var sentryTracer: SentryTracer
@@ -33,7 +33,7 @@ class SentryCrossProcessCursorTest {
       if (isSpanActive) {
         whenever(scopes.span).thenReturn(sentryTracer)
       }
-      return SentryCrossProcessCursor(mockCursor, spanManager, sql)
+      return SentryCrossProcessCursor(mockCursor, spans, sql)
     }
   }
 
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentrySupportSQLiteDatabaseTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentrySupportSQLiteDatabaseTest.kt
index 81bd964cc87..6a47eb6fa92 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentrySupportSQLiteDatabaseTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentrySupportSQLiteDatabaseTest.kt
@@ -23,7 +23,7 @@ import org.mockito.kotlin.whenever
 class SentrySupportSQLiteDatabaseTest {
   private class Fixture {
     private val scopes = mock<IScopes>()
-    private val spanManager = SQLiteSpanManager(scopes)
+    private val spans = OpenHelperSpans(scopes)
     val mockDatabase = mock<SupportSQLiteDatabase>()
     lateinit var sentryTracer: SentryTracer
     lateinit var options: SentryOptions
@@ -41,7 +41,7 @@ class SentrySupportSQLiteDatabaseTest {
         whenever(scopes.span).thenReturn(sentryTracer)
       }
 
-      return SentrySupportSQLiteDatabase(mockDatabase, spanManager)
+      return SentrySupportSQLiteDatabase(mockDatabase, spans)
     }
   }
 
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentrySupportSQLiteStatementTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentrySupportSQLiteStatementTest.kt
index b2b4998ace8..c4d810adbcd 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentrySupportSQLiteStatementTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentrySupportSQLiteStatementTest.kt
@@ -18,7 +18,7 @@ import org.mockito.kotlin.whenever
 class SentrySupportSQLiteStatementTest {
   private class Fixture {
     private val scopes = mock<IScopes>()
-    private val spanManager = SQLiteSpanManager(scopes)
+    private val spans = OpenHelperSpans(scopes)
     val mockStatement = mock<SupportSQLiteStatement>()
     lateinit var sentryTracer: SentryTracer
     lateinit var options: SentryOptions
@@ -31,7 +31,7 @@ class SentrySupportSQLiteStatementTest {
       if (isSpanActive) {
         whenever(scopes.span).thenReturn(sentryTracer)
       }
-      return SentrySupportSQLiteStatement(mockStatement, spanManager, sql)
+      return SentrySupportSQLiteStatement(mockStatement, spans, sql)
     }
   }
 
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/DriverSpansTest.kt
similarity index 77%
rename from sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
rename to sentry-android-sqlite/src/test/java/io/sentry/sqlite/DriverSpansTest.kt
index 74bd1c7f882..319fc20d7ce 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SQLiteSpanInstrumentationTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/DriverSpansTest.kt
@@ -21,7 +21,7 @@ import kotlin.test.assertTrue
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
 
-class SQLiteSpanInstrumentationTest {
+class DriverSpansTest {
 
   private class Fixture {
 
@@ -29,17 +29,14 @@ class SQLiteSpanInstrumentationTest {
     lateinit var sentryTracer: SentryTracer
     lateinit var options: SentryOptions
 
-    fun getSut(
-      isTransactionActive: Boolean = true,
-      fileName: String = ":memory:",
-    ): SQLiteSpanInstrumentation {
+    fun getSut(isTransactionActive: Boolean = true, fileName: String = ":memory:"): DriverSpans {
       options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
       whenever(scopes.options).thenReturn(options)
       sentryTracer = SentryTracer(TransactionContext("name", "op"), scopes)
       if (isTransactionActive) {
         whenever(scopes.span).thenReturn(sentryTracer)
       }
-      return SQLiteSpanInstrumentation.fromFileName(fileName, scopes)
+      return DriverSpans.fromFileName(fileName, scopes)
     }
   }
 
@@ -56,7 +53,7 @@ class SQLiteSpanInstrumentationTest {
     val start = sut.startTimestamp()
 
     val durationNanos = 42_000_000L
-    sut.recordSpan("SELECT 1", start, durationNanos, SpanStatus.OK)
+    sut.record("SELECT 1", start, durationNanos, SpanStatus.OK)
 
     val span = fixture.sentryTracer.children.first()
 
@@ -81,7 +78,7 @@ class SQLiteSpanInstrumentationTest {
     whenever(fixture.scopes.options).thenReturn(options)
     whenever(fixture.scopes.span).thenReturn(parentSpan)
 
-    val sut = SQLiteSpanInstrumentation.fromFileName(":memory:", fixture.scopes)
+    val sut = DriverSpans.fromFileName(":memory:", fixture.scopes)
 
     assertEquals(providerDate.nanoTimestamp(), sut.startTimestamp())
   }
@@ -97,31 +94,31 @@ class SQLiteSpanInstrumentationTest {
     whenever(fixture.scopes.options).thenReturn(options)
     whenever(fixture.scopes.span).thenReturn(null)
 
-    val sut = SQLiteSpanInstrumentation.fromFileName(":memory:", fixture.scopes)
+    val sut = DriverSpans.fromFileName(":memory:", fixture.scopes)
 
     assertEquals(providerDate.nanoTimestamp(), sut.startTimestamp())
   }
 
   @Test
-  fun `recordSpan records a span if a transaction is active`() {
+  fun `record method records a span if a transaction is active`() {
     val sut = fixture.getSut(isTransactionActive = true)
-    sut.recordSpan("SELECT 1", sut.startTimestamp(), 1_000_000, SpanStatus.OK)
+    sut.record("SELECT 1", sut.startTimestamp(), 1_000_000, SpanStatus.OK)
     assertEquals(1, fixture.sentryTracer.children.size)
   }
 
   @Test
-  fun `recordSpan does not record a span if no transaction is active`() {
+  fun `record method does not record a span if no transaction is active`() {
     val sut = fixture.getSut(isTransactionActive = false)
     val start = sut.startTimestamp()
-    sut.recordSpan("SELECT 1", start, 1_000_000, SpanStatus.OK)
+    sut.record("SELECT 1", start, 1_000_000, SpanStatus.OK)
     assertEquals(0, fixture.sentryTracer.children.size)
   }
 
   @Test
-  fun `recordSpan creates a span with correct properties`() {
+  fun `record method creates a span with correct properties`() {
     val sut = fixture.getSut()
     val start = sut.startTimestamp()
-    sut.recordSpan("SELECT * FROM users", start, 1_000_000, SpanStatus.OK)
+    sut.record("SELECT * FROM users", start, 1_000_000, SpanStatus.OK)
 
     val span = fixture.sentryTracer.children.firstOrNull()
     assertNotNull(span)
@@ -133,24 +130,24 @@ class SQLiteSpanInstrumentationTest {
   }
 
   @Test
-  fun `recordSpan sets finishDate equal to startDate + durationNanos`() {
+  fun `record method sets finishDate equal to startDate + durationNanos`() {
     val sut = fixture.getSut()
     val start = sut.startTimestamp()
     val durationNanos = 42_000_000L
 
-    sut.recordSpan("SELECT 1", start, durationNanos, SpanStatus.OK)
+    sut.record("SELECT 1", start, durationNanos, SpanStatus.OK)
 
     val span = fixture.sentryTracer.children.first()
     assertEquals(span.startDate.nanoTimestamp() + durationNanos, span.finishDate!!.nanoTimestamp())
   }
 
   @Test
-  fun `recordSpan attaches throwable when provided`() {
+  fun `record method attaches throwable when provided`() {
     val sut = fixture.getSut()
     val start = sut.startTimestamp()
     val exception = RuntimeException("disk I/O error")
 
-    sut.recordSpan("INSERT INTO t VALUES(1)", start, 500_000, SpanStatus.INTERNAL_ERROR, exception)
+    sut.record("INSERT INTO t VALUES(1)", start, 500_000, SpanStatus.INTERNAL_ERROR, exception)
 
     val span = fixture.sentryTracer.children.first()
     assertEquals(SpanStatus.INTERNAL_ERROR, span.status)
@@ -158,10 +155,10 @@ class SQLiteSpanInstrumentationTest {
   }
 
   @Test
-  fun `recordSpan sets db system and db name when fileName is not the in-memory sentinel`() {
+  fun `record method sets db system and db name when fileName is not the in-memory sentinel`() {
     val sut = fixture.getSut(fileName = "/data/data/com.example/databases/tracks.db")
     val start = sut.startTimestamp()
-    sut.recordSpan("SELECT 1", start, 1_000_000, SpanStatus.OK)
+    sut.record("SELECT 1", start, 1_000_000, SpanStatus.OK)
 
     val span = fixture.sentryTracer.children.first()
     assertEquals("sqlite", span.data[SpanDataConvention.DB_SYSTEM_KEY])
@@ -169,10 +166,10 @@ class SQLiteSpanInstrumentationTest {
   }
 
   @Test
-  fun `recordSpan sets db system only when fileName is the in-memory sentinel`() {
+  fun `record method sets db system only when fileName is the in-memory sentinel`() {
     val sut = fixture.getSut(fileName = ":memory:")
     val start = sut.startTimestamp()
-    sut.recordSpan("SELECT 1", start, 1_000_000, SpanStatus.OK)
+    sut.record("SELECT 1", start, 1_000_000, SpanStatus.OK)
 
     val span = fixture.sentryTracer.children.first()
     assertEquals("in-memory", span.data[SpanDataConvention.DB_SYSTEM_KEY])
@@ -180,13 +177,13 @@ class SQLiteSpanInstrumentationTest {
   }
 
   @Test
-  fun `recordSpan sets blocked_main_thread to true and attaches call stack on main thread`() {
+  fun `record method sets blocked_main_thread to true and attaches call stack on main thread`() {
     val sut = fixture.getSut()
     fixture.options.threadChecker = mock<IThreadChecker>()
     whenever(fixture.options.threadChecker.isMainThread).thenReturn(true)
     whenever(fixture.options.threadChecker.currentThreadName).thenReturn("main")
 
-    sut.recordSpan("SELECT 1", sut.startTimestamp(), 1_000_000, SpanStatus.OK)
+    sut.record("SELECT 1", sut.startTimestamp(), 1_000_000, SpanStatus.OK)
 
     val span = fixture.sentryTracer.children.first()
     assertTrue(span.getData(SpanDataConvention.BLOCKED_MAIN_THREAD_KEY) as Boolean)
@@ -194,20 +191,20 @@ class SQLiteSpanInstrumentationTest {
   }
 
   @Test
-  fun `recordSpan sets blocked_main_thread to false and does not attach a call stack on background thread`() {
+  fun `record method sets blocked_main_thread to false and does not attach a call stack on background thread`() {
     val sut = fixture.getSut()
     fixture.options.threadChecker = mock<IThreadChecker>()
     whenever(fixture.options.threadChecker.isMainThread).thenReturn(false)
     whenever(fixture.options.threadChecker.currentThreadName).thenReturn("worker")
 
-    sut.recordSpan("SELECT 1", sut.startTimestamp(), 1_000_000, SpanStatus.OK)
+    sut.record("SELECT 1", sut.startTimestamp(), 1_000_000, SpanStatus.OK)
 
     val span = fixture.sentryTracer.children.first()
     assertFalse(span.getData(SpanDataConvention.BLOCKED_MAIN_THREAD_KEY) as Boolean)
     assertNull(span.getData(SpanDataConvention.CALL_STACK_KEY))
   }
 
-  private fun setUpWithNanotimeDates(vararg dates: SentryNanotimeDate): SQLiteSpanInstrumentation {
+  private fun setUpWithNanotimeDates(vararg dates: SentryNanotimeDate): DriverSpans {
     val dateQueue = ArrayDeque(dates.toList())
     val options =
       SentryOptions().apply {
@@ -217,6 +214,6 @@ class SQLiteSpanInstrumentationTest {
     whenever(fixture.scopes.options).thenReturn(options)
     fixture.sentryTracer = SentryTracer(TransactionContext("name", "op"), fixture.scopes)
     whenever(fixture.scopes.span).thenReturn(fixture.sentryTracer)
-    return SQLiteSpanInstrumentation.fromFileName(":memory:", fixture.scopes)
+    return DriverSpans.fromFileName(":memory:", fixture.scopes)
   }
 }
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteConnectionTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteConnectionTest.kt
index b405d054f03..212e3b032e4 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteConnectionTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteConnectionTest.kt
@@ -24,7 +24,7 @@ class SentrySQLiteConnectionTest {
       options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
       whenever(scopes.options).thenReturn(options)
       whenever(mockConnection.prepare("SELECT 1")).thenReturn(mockStatement)
-      val spans = SQLiteSpanInstrumentation.fromFileName("test.db", scopes)
+      val spans = DriverSpans.fromFileName("test.db", scopes)
       return SentrySQLiteConnection(mockConnection, spans)
     }
   }
@@ -41,7 +41,7 @@ class SentrySQLiteConnectionTest {
   @Test
   fun `prepare with already-wrapped statement returns same instance without re-wrapping`() {
     val sut = fixture.getSut()
-    val spans = SQLiteSpanInstrumentation.fromFileName("test.db", fixture.scopes)
+    val spans = DriverSpans.fromFileName("test.db", fixture.scopes)
     val alreadyInstrumented = SentrySQLiteStatement(fixture.mockStatement, spans, "SELECT 1")
     whenever(fixture.mockConnection.prepare("SELECT 1")).thenReturn(alreadyInstrumented)
 
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt
index ce2c3f00cd5..bc6b074545a 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/sqlite/SentrySQLiteStatementTest.kt
@@ -19,7 +19,7 @@ class SentrySQLiteStatementTest {
 
   private class Fixture {
     val mockStatement = mock<SQLiteStatement>()
-    val mockSpans = mock<SQLiteSpanInstrumentation>()
+    val mockSpans = mock<DriverSpans>()
     val startTimestampNanos = 1_000_000_000_000L
     val fakeClock = AtomicLong(0L)
 
@@ -40,7 +40,7 @@ class SentrySQLiteStatementTest {
     verifyNeverCalledRecordSpan()
     sut.step()
     verify(fixture.mockSpans)
-      .recordSpan(
+      .record(
         eq("SELECT * FROM users"),
         eq(fixture.startTimestampNanos),
         any(),
@@ -58,7 +58,7 @@ class SentrySQLiteStatementTest {
     assertFailsWith<RuntimeException> { sut.step() }
 
     verify(fixture.mockSpans)
-      .recordSpan(
+      .record(
         eq("BAD SQL"),
         eq(fixture.startTimestampNanos),
         any(),
@@ -224,7 +224,7 @@ class SentrySQLiteStatementTest {
     sut.step()
 
     val durationCaptor = argumentCaptor<Long>()
-    verify(fixture.mockSpans).recordSpan(any(), any(), durationCaptor.capture(), any(), anyOrNull())
+    verify(fixture.mockSpans).record(any(), any(), durationCaptor.capture(), any(), anyOrNull())
     // Each step contributes its internal time (10 + 20 + 30) plus one unit from
     // fakeClock::getAndIncrement between before/after reads, so total is 63.
     assertEquals(63L, durationCaptor.firstValue)
@@ -285,6 +285,6 @@ class SentrySQLiteStatementTest {
   }
 
   private fun verifyCalledRecordSpan(times: Int = 1) {
-    verify(fixture.mockSpans, times(times)).recordSpan(any(), any(), any(), any(), anyOrNull())
+    verify(fixture.mockSpans, times(times)).record(any(), any(), any(), any(), anyOrNull())
   }
 }

From 05aa61daa3d25b2c82424779b5dec47c2c37556b Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Fri, 19 Jun 2026 17:20:19 +0200
Subject: [PATCH 220/391] chore(samples-android): Adapt SQLite demo screen to
 SAGP build mode (#5568)

Exposes a `BuildConfig.USE_SAGP` property from the recently introduced -PuseSagp flag ([#5538](https://github.com/getsentry/sentry-java/pull/5538)).

Lets us update the SQLite screen in the Android sample app so that it swizzles between auto-instrumenting vs manually wrapping `SQLiteDriver`, depending on the whether SAGP was applied to the build.
---
 .../sentry-samples-android/build.gradle.kts   |  12 ++
 .../samples/android/sqlite/SQLiteActivity.kt  | 111 +++++++++++++-----
 .../samples/android/sqlite/SampleDatabases.kt |  45 ++++---
 3 files changed, 112 insertions(+), 56 deletions(-)

diff --git a/sentry-samples/sentry-samples-android/build.gradle.kts b/sentry-samples/sentry-samples-android/build.gradle.kts
index 74e3c3a57b8..96ded862f95 100644
--- a/sentry-samples/sentry-samples-android/build.gradle.kts
+++ b/sentry-samples/sentry-samples-android/build.gradle.kts
@@ -1,4 +1,5 @@
 import com.android.build.api.artifact.SingleArtifact
+import com.android.build.api.variant.BuildConfigField
 import com.android.build.api.variant.impl.VariantImpl
 import io.sentry.android.gradle.extensions.InstrumentationFeature
 import io.sentry.android.gradle.extensions.SentryPluginExtension
@@ -135,6 +136,17 @@ android {
   }
 
   androidComponents.onVariants { variant ->
+    variant.buildConfigFields?.put(
+      "USE_SAGP",
+      providers.provider {
+        BuildConfigField(
+          type = "boolean",
+          value = providers.gradleProperty("useSagp").isPresent.toString(),
+          comment = "Whether the Sentry Android Gradle Plugin was applied",
+        )
+      },
+    )
+
     val taskName = "toggle${variant.name.capitalized()}NativeLogging"
     val toggleNativeLoggingTask =
       project.tasks.register<ToggleNativeLoggingTask>(taskName) {
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt
index 9a27ecda353..54334b6e407 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SQLiteActivity.kt
@@ -22,6 +22,7 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.statusBarsPadding
 import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.foundation.verticalScroll
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.outlined.HelpOutline
@@ -45,6 +46,7 @@ import androidx.compose.material3.Text
 import androidx.compose.material3.TooltipBox
 import androidx.compose.material3.TooltipDefaults
 import androidx.compose.material3.rememberTooltipState
+import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -70,6 +72,7 @@ import io.sentry.SpanStatus
 import io.sentry.TransactionContext
 import io.sentry.TransactionOptions
 import io.sentry.protocol.SentryId
+import io.sentry.samples.android.BuildConfig
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -93,33 +96,45 @@ private val CONTROL_SECTION_GAP = TOGGLE_SECTION_GAP * 2
 
 private val SECTION_HEADER_HEIGHT = 28.dp
 
+private const val SAGP_DIRECT_DRIVER_MESSAGE =
+  "SAGP doesn't auto-instrument SQLiteDriver for direct use"
+
 /** Which sentry-android-sqlite integration the demo currently targets. */
 private enum class IntegrationMode(
   val color: Color,
   val segmentLabel: String,
   val apiName: String,
-  val subtitle: String,
 ) {
-  DRIVER(
-    SentryPurple,
-    "SQLiteDriver",
-    "SQLiteDriver",
-    "SentrySQLiteDriver.create(BundledSQLiteDriver)",
-  ),
-  OPEN_HELPER(
-    SentryPink,
-    "OpenHelper",
-    "SupportSQLiteOpenHelper",
-    "SentrySupportSQLiteOpenHelper.create(...)",
-  ),
+
+  DRIVER(SentryPurple, "SQLiteDriver", "SQLiteDriver"),
+  OPEN_HELPER(SentryPink, "OpenHelper", "SupportSQLiteOpenHelper"),
   // Not directly-supported, but lets us verify behavior when both the DRIVER and OPEN_HELPER
   // integrations are used together via the SupportSQLiteDriver bridge.
-  BRIDGE(
-    SentryOrange,
-    "Bridge",
-    "SupportSQLiteDriver bridge",
-    "SentrySQLiteDriver.create(SupportSQLiteDriver(Sentry helper))",
-  ),
+  BRIDGE(SentryOrange, "Bridge", "SupportSQLiteDriver bridge");
+
+  fun subtitle(): String =
+    when (this) {
+      DRIVER ->
+        if (BuildConfig.USE_SAGP) {
+          "BundledSQLiteDriver (SAGP auto-wrap)"
+        } else {
+          "SentrySQLiteDriver.create(BundledSQLiteDriver)"
+        }
+
+      OPEN_HELPER ->
+        if (BuildConfig.USE_SAGP) {
+          "FrameworkSQLiteOpenHelperFactory (SAGP auto-wrap)"
+        } else {
+          "SentrySupportSQLiteOpenHelper.create(...)"
+        }
+
+      BRIDGE ->
+        if (BuildConfig.USE_SAGP) {
+          "SupportSQLiteDriver(open helper) (SAGP auto-wrap)"
+        } else {
+          "SentrySQLiteDriver.create(SupportSQLiteDriver(Sentry helper))"
+        }
+    }
 }
 
 /**
@@ -318,6 +333,7 @@ class SQLiteActivity : ComponentActivity() {
               lerp(MaterialTheme.colorScheme.outline, integration.color, shimmer.value)
 
             Text(text = "SQLite Instrumentation", style = MaterialTheme.typography.headlineSmall)
+            SagpBuildPill()
 
             Spacer(Modifier.height(titleGap))
 
@@ -364,6 +380,7 @@ class SQLiteActivity : ComponentActivity() {
                 label = row.label,
                 color = integration.color,
                 variant = variant,
+                sagpDisabledReason = sagpDisabledReason(integration, row),
                 disabledReason = "${row.label} doesn't support the ${integration.apiName} stack",
               )
             }
@@ -447,7 +464,7 @@ class SQLiteActivity : ComponentActivity() {
   }
 
   @OptIn(ExperimentalMaterial3Api::class)
-  @androidx.compose.runtime.Composable
+  @Composable
   private fun IntegrationModeSelector(
     selected: IntegrationMode,
     onSelected: (IntegrationMode) -> Unit,
@@ -471,18 +488,36 @@ class SQLiteActivity : ComponentActivity() {
     }
 
     Text(
-      text = selected.subtitle,
+      text = selected.subtitle(),
       style = MaterialTheme.typography.bodySmall,
       color = Color.Gray,
       modifier = Modifier.padding(top = 6.dp),
     )
   }
 
+  @Composable
+  private fun SagpBuildPill() {
+    val useSagp = BuildConfig.USE_SAGP
+
+    Surface(
+      shape = RoundedCornerShape(percent = 50),
+      color = if (useSagp) SentryPurple.copy(alpha = 0.15f) else Color.Gray.copy(alpha = 0.2f),
+      modifier = Modifier.padding(top = 6.dp),
+    ) {
+      Text(
+        text = if (useSagp) "Built with SAGP" else "Built without SAGP",
+        style = MaterialTheme.typography.labelSmall,
+        color = if (useSagp) SentryPurple else Color.DarkGray,
+        modifier = Modifier.padding(horizontal = 10.dp, vertical = 4.dp),
+      )
+    }
+  }
+
   /**
    * A compact, left-justified labeled switch. [labelColor] defaults to [Color.Unspecified] so the
    * label inherits the default text color.
    */
-  @androidx.compose.runtime.Composable
+  @Composable
   private fun ToggleRow(
     label: String,
     checked: Boolean,
@@ -509,11 +544,11 @@ class SQLiteActivity : ComponentActivity() {
     }
   }
 
-  @androidx.compose.runtime.Composable
+  @Composable
   private fun SectionHeader(
     title: String,
     topPadding: Dp = 8.dp,
-    trailing: (@androidx.compose.runtime.Composable () -> Unit)? = null,
+    trailing: (@Composable () -> Unit)? = null,
   ) {
     Column(modifier = Modifier.fillMaxWidth().padding(top = topPadding)) {
       Row(verticalAlignment = Alignment.CenterVertically) {
@@ -529,7 +564,7 @@ class SQLiteActivity : ComponentActivity() {
    * tooltip that auto-dismisses after a few seconds.
    */
   @OptIn(ExperimentalMaterial3Api::class)
-  @androidx.compose.runtime.Composable
+  @Composable
   private fun HelpTooltip() {
     val tooltipState = rememberTooltipState(isPersistent = true)
     val scope = rememberCoroutineScope()
@@ -565,16 +600,19 @@ class SQLiteActivity : ComponentActivity() {
    * dimmed and, when clicked, explains why via a toast ([disabledReason]) instead of running.
    */
   @OptIn(ExperimentalFoundationApi::class)
-  @androidx.compose.runtime.Composable
+  @Composable
   private fun DemoRowButton(
     label: String,
     color: Color,
     variant: DemoVariant?,
+    sagpDisabledReason: String?,
     disabledReason: String,
   ) {
     val context = LocalContext.current
-    val enabled = variant != null
-    val explain = { Toast.makeText(context, disabledReason, Toast.LENGTH_SHORT).show() }
+    val enabled = variant != null && sagpDisabledReason == null
+    val explain = {
+      Toast.makeText(context, sagpDisabledReason ?: disabledReason, Toast.LENGTH_SHORT).show()
+    }
 
     Surface(
       modifier = Modifier.fillMaxWidth(),
@@ -585,8 +623,8 @@ class SQLiteActivity : ComponentActivity() {
       Box(
         modifier =
           Modifier.combinedClickable(
-              onClick = { if (variant != null) onTap(variant) else explain() },
-              onLongClick = { if (variant != null) onLongPress(variant) else explain() },
+              onClick = { if (enabled) onTap(variant) else explain() },
+              onLongClick = { if (enabled) onLongPress(variant) else explain() },
             )
             .fillMaxWidth()
             .heightIn(min = 44.dp)
@@ -598,7 +636,7 @@ class SQLiteActivity : ComponentActivity() {
     }
   }
 
-  @androidx.compose.runtime.Composable
+  @Composable
   private fun ResetButton(dbOperationInFlight: Boolean, resetInProgress: Boolean) {
     // Debounce demo-driven disablement so fast taps don't flicker the button; reset disables
     // immediately via [resetInProgress]. [dbOperationInFlight] still guards [onClick] either way.
@@ -642,7 +680,7 @@ class SQLiteActivity : ComponentActivity() {
     }
   }
 
-  @androidx.compose.runtime.Composable
+  @Composable
   private fun DetailField(label: String, value: String, borderColor: Color) {
     OutlinedTextField(
       value = value,
@@ -699,6 +737,15 @@ class SQLiteActivity : ComponentActivity() {
     }
   }
 
+  private fun sagpDisabledReason(mode: IntegrationMode, row: DemoRow): String? {
+    if (!BuildConfig.USE_SAGP) return null
+    val demo = row.variantFor(mode)?.demo ?: return null
+    return when (demo) {
+      SqlDemo.DRIVER_DIRECT -> SAGP_DIRECT_DRIVER_MESSAGE
+      else -> null
+    }
+  }
+
   /** Closes + deletes every demo database file (via [SampleDatabases]), then re-warms them. */
   private suspend fun resetDatabases(): String {
     val cleared = SampleDatabases.reset(applicationContext)
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt
index 19b292cd91e..f01a529499d 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/sqlite/SampleDatabases.kt
@@ -5,6 +5,7 @@ import android.util.Log
 import androidx.room.Room
 import androidx.room3.Room as Room3
 import androidx.sqlite.SQLiteConnection
+import androidx.sqlite.SQLiteDriver
 import androidx.sqlite.db.SupportSQLiteDatabase
 import androidx.sqlite.db.SupportSQLiteOpenHelper
 import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory
@@ -13,6 +14,7 @@ import androidx.sqlite.driver.bundled.BundledSQLiteDriver
 import androidx.sqlite.execSQL
 import app.cash.sqldelight.driver.android.AndroidSqliteDriver
 import io.sentry.android.sqlite.SentrySupportSQLiteOpenHelper
+import io.sentry.samples.android.BuildConfig
 import io.sentry.samples.android.sqlite.SampleDatabases.driverDirectLock
 import io.sentry.samples.android.sqlite.SampleDatabases.openHelperDirectLock
 import io.sentry.samples.android.sqlite.SampleDatabases.reset
@@ -85,12 +87,10 @@ object SampleDatabases {
   fun driverConnection(context: Context): SQLiteConnection =
     synchronized(driverDirectLock) {
       driverConnection
-        ?: SentrySQLiteDriver.create(BundledSQLiteDriver())
-          .open(databaseFile(context, "driver_direct.db"))
-          .also {
-            it.execSQL(SqlStatements.CREATE_SONG) // one-time table setup, at open
-            driverConnection = it
-          }
+        ?: wrapDriver(BundledSQLiteDriver()).open(databaseFile(context, "driver_direct.db")).also {
+          it.execSQL(SqlStatements.CREATE_SONG) // one-time table setup, at open
+          driverConnection = it
+        }
     }
 
   /**
@@ -104,7 +104,7 @@ object SampleDatabases {
           // SupportSQLiteDriver.open() requires fileName to match the helper's databaseName();
           // use the absolute path Room and the direct driver path both pass to open().
           val dbPath = databaseFile(context, "bridge_direct.db")
-          SentrySQLiteDriver.create(SupportSQLiteDriver(buildBridgeDirectHelper(context, dbPath)))
+          wrapDriver(SupportSQLiteDriver(buildBridgeDirectHelper(context, dbPath)))
             .open(dbPath)
             .also {
               it.execSQL(SqlStatements.CREATE_SONG)
@@ -122,9 +122,7 @@ object SampleDatabases {
             "bridge_room2.db",
           )
           .setDriver(
-            SentrySQLiteDriver.create(
-              SupportSQLiteDriver(buildBridgeRoom2Helper(context.applicationContext))
-            )
+            wrapDriver(SupportSQLiteDriver(buildBridgeRoom2Helper(context.applicationContext)))
           )
           .setQueryCoroutineContext(Dispatchers.IO)
           .fallbackToDestructiveMigration(true)
@@ -140,7 +138,7 @@ object SampleDatabases {
             SampleRoom2Database::class.java,
             "driver_room2.db",
           )
-          .setDriver(SentrySQLiteDriver.create(BundledSQLiteDriver()))
+          .setDriver(wrapDriver(BundledSQLiteDriver()))
           .setQueryCoroutineContext(Dispatchers.IO)
           .fallbackToDestructiveMigration(true)
           .build()
@@ -151,7 +149,7 @@ object SampleDatabases {
     synchronized(this) {
       driverRoom3Db
         ?: Room3.databaseBuilder<SampleRoom3Database>(context.applicationContext, "driver_room3.db")
-          .setDriver(SentrySQLiteDriver.create(BundledSQLiteDriver()))
+          .setDriver(wrapDriver(BundledSQLiteDriver()))
           .setQueryCoroutineContext(Dispatchers.IO)
           .build()
           .also { driverRoom3Db = it }
@@ -171,9 +169,7 @@ object SampleDatabases {
             "openhelper_room.db",
           )
           .openHelperFactory { configuration ->
-            SentrySupportSQLiteOpenHelper.create(
-              FrameworkSQLiteOpenHelperFactory().create(configuration)
-            )
+            wrapOpenHelper(FrameworkSQLiteOpenHelperFactory().create(configuration))
           }
           .fallbackToDestructiveMigration(true)
           .build()
@@ -189,9 +185,7 @@ object SampleDatabases {
             name = "openhelper_sqldelight.db",
             factory =
               SupportSQLiteOpenHelper.Factory { configuration ->
-                SentrySupportSQLiteOpenHelper.create(
-                  FrameworkSQLiteOpenHelperFactory().create(configuration)
-                )
+                wrapOpenHelper(FrameworkSQLiteOpenHelperFactory().create(configuration))
               },
           )
           .also { sqlDelightDriver = it }
@@ -232,9 +226,7 @@ object SampleDatabases {
           }
         )
         .build()
-    return SentrySupportSQLiteOpenHelper.create(
-      FrameworkSQLiteOpenHelperFactory().create(configuration)
-    )
+    return wrapOpenHelper(FrameworkSQLiteOpenHelperFactory().create(configuration))
   }
 
   private fun buildSentryHelper(context: Context, dbName: String): SupportSQLiteOpenHelper {
@@ -252,17 +244,22 @@ object SampleDatabases {
           }
         )
         .build()
-    return SentrySupportSQLiteOpenHelper.create(
-      FrameworkSQLiteOpenHelperFactory().create(configuration)
-    )
+    return wrapOpenHelper(FrameworkSQLiteOpenHelperFactory().create(configuration))
   }
 
+  private fun wrapDriver(driver: SQLiteDriver): SQLiteDriver =
+    if (BuildConfig.USE_SAGP) driver else SentrySQLiteDriver.create(driver)
+
+  private fun wrapOpenHelper(delegate: SupportSQLiteOpenHelper): SupportSQLiteOpenHelper =
+    if (BuildConfig.USE_SAGP) delegate else SentrySupportSQLiteOpenHelper.create(delegate)
+
   /** Opens every database on a background thread, forcing the one-time open + bootstrap to run. */
   fun warmUp(context: Context) {
     val appContext = context.applicationContext
     val generation = ++warmUpGeneration
     warmUpComplete = false
     warmUpErrors = ""
+    Log.i(TAG, "Warm-up starting (USE_SAGP=${BuildConfig.USE_SAGP})")
     // Fire-and-forget: the warm-up outlives no particular screen, so a bare scope is fine here.
     warmUpJob =
       CoroutineScope(Dispatchers.IO).launch {

From 0c118e902e8632b9fc107e8063613ea19fd11e70 Mon Sep 17 00:00:00 2001
From: Giancarlo Buenaflor <giancarlo_buenaflor@yahoo.com>
Date: Mon, 22 Jun 2026 11:02:52 +0200
Subject: [PATCH 221/391] feat(android): Report app start reason as
 `app.vitals.start.reason` on standalone app start transaction (#5552)

* feat(android): Report app start reason on standalone app start transaction

Read ApplicationStartInfo.getReason() (API 35+) and attach it as
app.start.reason trace data on the standalone app.start transaction
in both the foreground and headless paths.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(android): Register StandaloneAppStart SDK integration marker

Advertise that standalone app start tracing is active by adding a
StandaloneAppStart marker to the SDK metadata integrations when the
feature is enabled. Internal SDK metadata only.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(changelog): Note app.start.reason is searchable in Trace Explorer

Address review feedback to mention that customers can search and group
by the app.vitals.start.reason attribute.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../api/sentry-android-core.api               |  2 +
 .../core/ActivityLifecycleIntegration.java    | 10 +++
 .../core/performance/AppStartMetrics.java     | 45 ++++++++++++
 .../core/ActivityLifecycleIntegrationTest.kt  | 71 +++++++++++++++++++
 .../performance/AppStartMetricsTestApi35.kt   | 42 +++++++++++
 6 files changed, 171 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b3bdcd38bc4..5d9d4dddac0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -27,6 +27,7 @@
   - Emits a transaction named `App Start` with op `app.start`, carrying the existing app start measurements and phase spans (`process.load`, `contentprovider.load`, `application.load`, activity lifecycle spans) as direct children of the root
   - The standalone transaction shares the same `traceId` as the first `ui.load` activity transaction so they remain linked in the trace view
   - Also covers non-activity starts (broadcast receivers, services, content providers)
+  - On Android 15+ (API 35), the standalone `app.start` transaction reports why the OS started the process via `app.vitals.start.reason` trace data (e.g. `launcher`, `broadcast`, `service`, `content_provider`), derived from `ApplicationStartInfo.getReason()`. You can search and group by this attribute in the Trace Explorer. ([#5552](https://github.com/getsentry/sentry-java/pull/5552))
 
 ### Improvements
 
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 0500ba44990..58325d08b5b 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -746,6 +746,7 @@ public class io/sentry/android/core/performance/AppStartMetrics : io/sentry/andr
 	public fun getAppStartContinuousProfiler ()Lio/sentry/IContinuousProfiler;
 	public fun getAppStartEndTime ()Lio/sentry/SentryDate;
 	public fun getAppStartProfiler ()Lio/sentry/ITransactionProfiler;
+	public fun getAppStartReason ()Ljava/lang/String;
 	public fun getAppStartSamplingDecision ()Lio/sentry/TracesSamplingDecision;
 	public fun getAppStartSentryTraceHeader ()Ljava/lang/String;
 	public fun getAppStartTimeSpan ()Lio/sentry/android/core/performance/TimeSpan;
@@ -780,6 +781,7 @@ public class io/sentry/android/core/performance/AppStartMetrics : io/sentry/andr
 	public fun setAppStartSentryTraceHeader (Ljava/lang/String;)V
 	public fun setAppStartTraceId (Lio/sentry/protocol/SentryId;)V
 	public fun setAppStartType (Lio/sentry/android/core/performance/AppStartMetrics$AppStartType;)V
+	public fun setCachedStartInfo (Landroid/app/ApplicationStartInfo;)V
 	public fun setClassLoadedUptimeMs (J)V
 	public fun setHeadlessAppStartListener (Lio/sentry/android/core/performance/AppStartMetrics$HeadlessAppStartListener;)V
 	public fun shouldSendStartMeasurements ()Z
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
index 8a891926341..d70ff837178 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
@@ -71,6 +71,7 @@ public final class ActivityLifecycleIntegration
   static final long APP_START_TO_UI_LOAD_CONTINUATION_MAX_GAP_NANOS = TimeUnit.MINUTES.toNanos(1);
   private static final String TRACE_ORIGIN = "auto.ui.activity";
   static final String APP_START_SCREEN_DATA = "app.vitals.start.screen";
+  static final String APP_START_REASON_DATA = "app.vitals.start.reason";
   static final String APP_START_TRACE_ORIGIN = "auto.app.start";
 
   private final @NotNull Application application;
@@ -139,6 +140,7 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
 
     if (performanceEnabled && this.options.isEnableStandaloneAppStartTracing()) {
       AppStartMetrics.getInstance().setHeadlessAppStartListener(this::onHeadlessAppStart);
+      addIntegrationToSdkVersion("StandaloneAppStart");
     }
 
     this.options.getLogger().log(SentryLevel.DEBUG, "ActivityLifecycleIntegration installed.");
@@ -285,6 +287,10 @@ private void startTracing(final @NotNull Activity activity) {
                       appStartSamplingDecision),
                   appStartTransactionOptions);
           appStartTransaction.setData(APP_START_SCREEN_DATA, activityName);
+          final @Nullable String appStartReason = AppStartMetrics.getInstance().getAppStartReason();
+          if (appStartReason != null) {
+            appStartTransaction.setData(APP_START_REASON_DATA, appStartReason);
+          }
         }
 
         // Continue either the foreground app.start above or an earlier headless app.start.
@@ -1001,6 +1007,10 @@ private void onHeadlessAppStart() {
             null);
 
     final @NotNull ITransaction transaction = scopes.startTransaction(txnContext, txnOptions);
+    final @Nullable String appStartReason = metrics.getAppStartReason();
+    if (appStartReason != null) {
+      transaction.setData(APP_START_REASON_DATA, appStartReason);
+    }
     metrics.setAppStartTraceId(transaction.getSpanContext().getTraceId());
     // Persist trace headers so a later ui.load can share traceId and sampleRand.
     metrics.setAppStartSentryTraceHeader(transaction.toSentryTrace().getValue());
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
index d8cb0827ba4..36cae8686ca 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
@@ -166,6 +166,45 @@ public void setAppStartType(final @NotNull AppStartType appStartType) {
     return appStartType;
   }
 
+  /**
+   * The reason the OS started the process, mapped from {@link ApplicationStartInfo#getReason()}.
+   * Only available on API 35+ (when {@link #cachedStartInfo} was resolved); returns {@code null}
+   * otherwise or for an unmapped reason.
+   */
+  public @Nullable String getAppStartReason() {
+    if (cachedStartInfo == null || Build.VERSION.SDK_INT < Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+      return null;
+    }
+    switch (cachedStartInfo.getReason()) {
+      case ApplicationStartInfo.START_REASON_ALARM:
+        return "alarm";
+      case ApplicationStartInfo.START_REASON_BACKUP:
+        return "backup";
+      case ApplicationStartInfo.START_REASON_BOOT_COMPLETE:
+        return "boot_complete";
+      case ApplicationStartInfo.START_REASON_BROADCAST:
+        return "broadcast";
+      case ApplicationStartInfo.START_REASON_CONTENT_PROVIDER:
+        return "content_provider";
+      case ApplicationStartInfo.START_REASON_JOB:
+        return "job";
+      case ApplicationStartInfo.START_REASON_LAUNCHER:
+        return "launcher";
+      case ApplicationStartInfo.START_REASON_LAUNCHER_RECENTS:
+        return "launcher_recents";
+      case ApplicationStartInfo.START_REASON_PUSH:
+        return "push";
+      case ApplicationStartInfo.START_REASON_SERVICE:
+        return "service";
+      case ApplicationStartInfo.START_REASON_START_ACTIVITY:
+        return "start_activity";
+      case ApplicationStartInfo.START_REASON_OTHER:
+        return "other";
+      default:
+        return null;
+    }
+  }
+
   public boolean isAppLaunchedInForeground() {
     return appLaunchedInForeground.getValue();
   }
@@ -372,6 +411,12 @@ public void setClassLoadedUptimeMs(final long classLoadedUptimeMs) {
     CLASS_LOADED_UPTIME_MS = classLoadedUptimeMs;
   }
 
+  @TestOnly
+  @ApiStatus.Internal
+  public void setCachedStartInfo(final @Nullable ApplicationStartInfo cachedStartInfo) {
+    this.cachedStartInfo = cachedStartInfo;
+  }
+
   /**
    * Called by instrumentation
    *
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
index 19f43432bef..8b842a0cfa9 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
@@ -4,6 +4,7 @@ import android.app.Activity
 import android.app.ActivityManager
 import android.app.ActivityManager.RunningAppProcessInfo
 import android.app.Application
+import android.app.ApplicationStartInfo
 import android.content.Context
 import android.os.Build
 import android.os.Bundle
@@ -274,6 +275,76 @@ class ActivityLifecycleIntegrationTest {
     )
   }
 
+  @Test
+  @Config(sdk = [Build.VERSION_CODES.VANILLA_ICE_CREAM])
+  fun `Standalone app start transaction carries app start reason when available`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    val startInfo =
+      mock<ApplicationStartInfo>().apply {
+        whenever(reason).thenReturn(ApplicationStartInfo.START_REASON_LAUNCHER)
+      }
+    AppStartMetrics.getInstance().setCachedStartInfo(startInfo)
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val appStartTransaction =
+      fixture.createdTransactions.single {
+        it.spanContext.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+      }
+    assertEquals("launcher", appStartTransaction.getData("app.vitals.start.reason"))
+  }
+
+  @Test
+  fun `Standalone app start transaction has no app start reason when unavailable`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val appStartTransaction =
+      fixture.createdTransactions.single {
+        it.spanContext.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+      }
+    assertNull(appStartTransaction.getData("app.vitals.start.reason"))
+  }
+
+  @Test
+  @Config(sdk = [Build.VERSION_CODES.VANILLA_ICE_CREAM])
+  fun `Headless standalone app start transaction carries app start reason when available`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+    prepareHeadlessAppStart(appStartType = AppStartType.COLD)
+    val startInfo =
+      mock<ApplicationStartInfo>().apply {
+        whenever(reason).thenReturn(ApplicationStartInfo.START_REASON_BROADCAST)
+      }
+    AppStartMetrics.getInstance().setCachedStartInfo(startInfo)
+
+    driveHeadlessAppStart()
+
+    val transaction = fixture.createdTransactions.single()
+    assertEquals("broadcast", transaction.getData("app.vitals.start.reason"))
+  }
+
   @Test
   fun `HeadlessAppStartListener is registered when standalone flag is on and performance enabled`() {
     val sut =
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
index 30686852156..b5d87ab77cb 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
@@ -15,6 +15,7 @@ import java.util.concurrent.atomic.AtomicInteger
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertNull
 import org.junit.Before
 import org.junit.runner.RunWith
 import org.mockito.kotlin.mock
@@ -207,6 +208,47 @@ class AppStartMetricsTestApi35 {
     assertEquals(1, listenerCalls.get())
   }
 
+  @Test
+  fun `getAppStartReason maps ApplicationStartInfo reason to string on API 35`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    whenever(mockStartInfo.reason).thenReturn(ApplicationStartInfo.START_REASON_BROADCAST)
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    val metrics = AppStartMetrics.getInstance()
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    assertEquals("broadcast", metrics.appStartReason)
+  }
+
+  @Test
+  fun `getAppStartReason returns null when no ApplicationStartInfo is available`() {
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(emptyList())
+    val metrics = AppStartMetrics.getInstance()
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    assertNull(metrics.appStartReason)
+  }
+
+  @Test
+  fun `getAppStartReason returns null for an unmapped reason`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    whenever(mockStartInfo.reason).thenReturn(Int.MAX_VALUE)
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    val metrics = AppStartMetrics.getInstance()
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    assertNull(metrics.appStartReason)
+  }
+
   private fun waitForMainLooperIdle() {
     Handler(Looper.getMainLooper()).post {}
     Shadows.shadowOf(Looper.getMainLooper()).idle()

From f037273666b1f288823a4d6a135dcf517dd61468 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 22 Jun 2026 14:00:00 +0200
Subject: [PATCH 222/391] fix(replay): Release MediaMuxer when no frames are
 encoded (#5583)

* fix(replay): Release MediaMuxer when no frames are encoded

The MediaMuxer is created when the video encoder is constructed, but its
release() was reachable only on the happy path. Two cases leaked it:

- createVideoOf returned early when frameCount was 0 without releasing the
  encoder.
- SimpleMp4FrameMuxer.release() called muxer.stop() before muxer.release().
  stop() throws if the muxer was never started (no frame ever muxed), so
  release() was skipped.

This surfaced as a CloseGuard "resource was acquired but never released"
warning. Guard stop() behind the started flag so release() is always
reached, and release the encoder on the no-frames return path.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                                | 6 ++++++
 .../src/main/java/io/sentry/android/replay/ReplayCache.kt   | 4 ++++
 .../io/sentry/android/replay/video/SimpleMp4FrameMuxer.kt   | 6 +++++-
 3 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5d9d4dddac0..8d66d755a7c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Release `MediaMuxer` when a replay segment has no encodable frames to avoid a resource leak ([#5583](https://github.com/getsentry/sentry-java/pull/5583))
+
 ## 8.44.1
 
 ### Fixes
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
index 32e42dafac1..b3b9edae055 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
@@ -199,6 +199,10 @@ public class ReplayCache(private val options: SentryOptions, private val replayI
 
     if (frameCount == 0) {
       options.logger.log(DEBUG, "Generated a video with no frames, not capturing a replay segment")
+      encoderLock.acquire().use {
+        encoder?.release()
+        encoder = null
+      }
       deleteFile(videoFile)
       return null
     }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleMp4FrameMuxer.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleMp4FrameMuxer.kt
index 36741686701..e32af9bb44b 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleMp4FrameMuxer.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleMp4FrameMuxer.kt
@@ -67,7 +67,11 @@ internal class SimpleMp4FrameMuxer(path: String, fps: Float) : SimpleFrameMuxer
   }
 
   override fun release() {
-    muxer.stop()
+    // stop() throws if the muxer was never started (e.g. no frame was ever muxed), so we guard it
+    // to ensure release() is always reached and the underlying resources are freed
+    if (started) {
+      muxer.stop()
+    }
     muxer.release()
   }
 

From 57d359a2dee07eb48c5b2f6fad04d540af7fe407 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 22 Jun 2026 14:21:24 +0200
Subject: [PATCH 223/391] docs(replay): Add THIRD_PARTY_NOTICES entry for
 SimpleMp4FrameMuxer (#5586)

* docs(replay): Add THIRD_PARTY_NOTICES entry for SimpleMp4FrameMuxer

SimpleMp4FrameMuxer is adapted from the flutter_screen_recorder library
and carries a complete attribution header, but the corresponding entry
in THIRD_PARTY_NOTICES.md was never added. Warden's check-code-attribution
flags the missing entry as independently required regardless of header
completeness.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(replay): Cover all adapted flutter_screen_recorder and Curtains files

SimpleFrameMuxer and SimpleVideoEncoder are adapted from the same
flutter_screen_recorder library as SimpleMp4FrameMuxer; fold all three
into one notice entry. Also extend the existing Square Curtains scope to
list io.sentry.android.replay.Windows, which is adapted from Curtains but
was not mentioned.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(replay): Correct adapted-from URL in SimpleVideoEncoder header

The attribution header pointed at the upstream SimpleFrameMuxer.kt
instead of SimpleVideoEncoder.kt.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 THIRD_PARTY_NOTICES.md                        | 39 ++++++++++++++++++-
 .../replay/video/SimpleVideoEncoder.kt        |  2 +-
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index c1fa7e8f65b..925add4a71a 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -154,7 +154,7 @@ limitations under the License.
 
 ### Scope
 
-The Sentry Java SDK includes an adapted version of Square's Curtains library for null-safe `Window.Callback` handling. The code resides in `io.sentry.android.replay.util.FixedWindowCallback`.
+The Sentry Java SDK includes adapted versions of Square's Curtains library for null-safe `Window.Callback` handling and for tracking attached window roots. The code resides in `io.sentry.android.replay.util.FixedWindowCallback` and `io.sentry.android.replay.Windows`.
 
 ```
 Copyright 2021 Square Inc.
@@ -513,3 +513,40 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
+
+---
+
+## fzyzcjy — Flutter Screen Recorder (MIT)
+
+**Source:** https://github.com/fzyzcjy/flutter_screen_recorder (Commit: dce41cec25c66baf42c6bac4198e95874ce3eb9d)<br>
+**License:** MIT License<br>
+**Copyright:** Copyright (c) 2021 fzyzcjy
+
+### Scope
+
+The Sentry Android Replay SDK includes adapted versions of the video encoding and muxing classes from the flutter_screen_recorder library, used to encode and mux replay video frames into an MP4 file. The code resides in the `io.sentry.android.replay.video` package and includes `SimpleFrameMuxer`, `SimpleMp4FrameMuxer`, and `SimpleVideoEncoder`.
+
+```
+Copyright (c) 2021 fzyzcjy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+In addition to the standard MIT license, this library requires the following: The recorder itself
+only saves data on user's phone locally, thus it does not have any privacy problem. However, if
+you are going to get the records out of the local storage (e.g. upload the records to your
+server), please explicitly ask the user for permission, and promise to only use the records to
+debug your app. This is a part of the license of this library.
+```
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
index a400be865e7..de14aadaaab 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
@@ -1,6 +1,6 @@
 /**
  * Adapted from
- * https://github.com/fzyzcjy/flutter_screen_recorder/blob/dce41cec25c66baf42c6bac4198e95874ce3eb9d/packages/fast_screen_recorder/android/src/main/kotlin/com/cjy/fast_screen_recorder/SimpleFrameMuxer.kt
+ * https://github.com/fzyzcjy/flutter_screen_recorder/blob/dce41cec25c66baf42c6bac4198e95874ce3eb9d/packages/fast_screen_recorder/android/src/main/kotlin/com/cjy/fast_screen_recorder/SimpleVideoEncoder.kt
  *
  * Copyright (c) 2021 fzyzcjy
  *

From f982bad2175a3302c67624af6ec2bd27d72a549f Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 23 Jun 2026 11:13:24 +0200
Subject: [PATCH 224/391] build(samples): Remove outputs.upToDateWhen { false }
 from systemTest tasks (#5522)

* build(samples): Remove outputs.upToDateWhen { false } from systemTest tasks

The systemTest tasks in the sample modules forced Gradle to always treat
their outputs as out of date, disabling up-to-date checks and build cache
reuse. Removing this lets Gradle rely on its normal input/output tracking
for the Test tasks.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* build(samples): Track systemTest app archive via convention plugin

The system tests launch the packaged sample (war/shadowJar/bootJar) from
build/libs as a separate process, so the archive is a real input to the
systemTest task even though it is not on the test classpath. Without it,
removing outputs.upToDateWhen { false } would let Gradle mark systemTest
up-to-date while a separate jar build refreshed the artifact, skipping
verification against the rebuilt sample.

Move that wiring into a single io.sentry.systemtest convention plugin in
build-logic instead of repeating it in every sample build file. The
plugin auto-detects the packaging task (war, else shadowJar, else
bootJar), mirroring the selection in test/system-test-runner.py, and
declares its archive as an input and dependency. Each sample just
applies the plugin.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* build(samples): Track OpenTelemetry agent jar as systemTest input

The agent-based OpenTelemetry samples are launched by the runner with
-javaagent:<sentry-opentelemetry-agent>, started outside the test JVM.
That jar is not on the test classpath nor one of the app archives, so
without tracking it systemTest could stay up-to-date and be skipped
while the runner launches a newer agent.

Add a usesOpenTelemetryAgent opt-in to the io.sentry.systemtest plugin;
the three agent samples enable it and the agent jar is then tracked as a
content input. The runner already builds and launches the agent before
invoking the task, so it is tracked by path without a cross-project task
dependency, which keeps it configuration-on-demand and configuration
cache compatible.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../kotlin/io.sentry.systemtest.gradle.kts    | 38 +++++++++++++++++++
 .../io/sentry/gradle/SystemTestExtension.kt   | 17 +++++++++
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  3 +-
 .../sentry-samples-console/build.gradle.kts   |  3 +-
 .../sentry-samples-jul/build.gradle.kts       |  3 +-
 .../sentry-samples-log4j2/build.gradle.kts    |  3 +-
 .../sentry-samples-logback/build.gradle.kts   |  3 +-
 .../sentry-samples-spring-7/build.gradle.kts  |  3 +-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  6 ++-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  6 ++-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  6 ++-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  3 +-
 .../build.gradle.kts                          |  3 +-
 .../sentry-samples-spring/build.gradle.kts    |  3 +-
 24 files changed, 86 insertions(+), 44 deletions(-)
 create mode 100644 build-logic/src/main/kotlin/io.sentry.systemtest.gradle.kts
 create mode 100644 build-logic/src/main/kotlin/io/sentry/gradle/SystemTestExtension.kt

diff --git a/build-logic/src/main/kotlin/io.sentry.systemtest.gradle.kts b/build-logic/src/main/kotlin/io.sentry.systemtest.gradle.kts
new file mode 100644
index 00000000000..a21079e1336
--- /dev/null
+++ b/build-logic/src/main/kotlin/io.sentry.systemtest.gradle.kts
@@ -0,0 +1,38 @@
+import io.sentry.gradle.SystemTestExtension
+import org.gradle.api.tasks.ClasspathNormalizer
+
+val systemTest = extensions.create<SystemTestExtension>("sentrySystemTest")
+
+// The sample system tests launch the packaged app (war/shadowJar/bootJar) from build/libs as a
+// separate process, so the archive is a real input even though it is not on the test classpath.
+// Agent-based samples are additionally launched with -javaagent:<otel agent>, another runtime
+// input not on the classpath. See test/system-test-runner.py.
+tasks.matching { it.name == "systemTest" }.configureEach {
+  val archiveTask =
+    listOf("war", "shadowJar", "bootJar").firstOrNull { it in tasks.names }
+      ?: throw GradleException(
+        "io.sentry.systemtest is applied to $path but none of war/shadowJar/bootJar " +
+          "exist to provide the launched app archive for the systemTest task"
+      )
+  // Declaring the archive as an input also wires the dependency on its producing task.
+  inputs
+    .files(tasks.named(archiveTask))
+    .withPropertyName("appArchive")
+    .withNormalizer(ClasspathNormalizer::class.java)
+
+  if (systemTest.usesOpenTelemetryAgent.get()) {
+    // The runner builds the agent and launches the app with -javaagent before invoking this task,
+    // so the agent jar is tracked for content only (by path, no cross-project task dependency): a
+    // change to it makes systemTest out of date even though it runs outside the test JVM.
+    val version = providers.gradleProperty("versionName").get()
+    inputs
+      .files(
+        rootProject.layout.projectDirectory.file(
+          "sentry-opentelemetry/sentry-opentelemetry-agent/build/libs/" +
+            "sentry-opentelemetry-agent-$version.jar"
+        )
+      )
+      .withPropertyName("openTelemetryAgent")
+      .withNormalizer(ClasspathNormalizer::class.java)
+  }
+}
diff --git a/build-logic/src/main/kotlin/io/sentry/gradle/SystemTestExtension.kt b/build-logic/src/main/kotlin/io/sentry/gradle/SystemTestExtension.kt
new file mode 100644
index 00000000000..9111ce17b1f
--- /dev/null
+++ b/build-logic/src/main/kotlin/io/sentry/gradle/SystemTestExtension.kt
@@ -0,0 +1,17 @@
+package io.sentry.gradle
+
+import org.gradle.api.provider.Property
+
+/** Configuration for the `io.sentry.systemtest` convention plugin. */
+abstract class SystemTestExtension {
+  /**
+   * Set to `true` for samples that the system-test runner launches with the Sentry OpenTelemetry
+   * Java agent (`-javaagent`). The agent jar is then tracked as a `systemTest` input so the task
+   * re-runs when the agent changes, even though it is started outside the test JVM.
+   */
+  abstract val usesOpenTelemetryAgent: Property<Boolean>
+
+  init {
+    usesOpenTelemetryAgent.convention(false)
+  }
+}
diff --git a/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
index f5d14dc2c38..9db90129958 100644
--- a/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.shadow)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.console.Main") }
@@ -71,8 +72,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-console-otlp/build.gradle.kts b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
index 483f6bea799..261894baaa0 100644
--- a/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.shadow)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.console.Main") }
@@ -74,8 +75,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-console/build.gradle.kts b/sentry-samples/sentry-samples-console/build.gradle.kts
index 79878ab9a08..3e70e79ae71 100644
--- a/sentry-samples/sentry-samples-console/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.shadow)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.console.Main") }
@@ -75,8 +76,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-jul/build.gradle.kts b/sentry-samples/sentry-samples-jul/build.gradle.kts
index 01e6a95f13d..310af1e7bce 100644
--- a/sentry-samples/sentry-samples-jul/build.gradle.kts
+++ b/sentry-samples/sentry-samples-jul/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.shadow)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.jul.Main") }
@@ -66,8 +67,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-log4j2/build.gradle.kts b/sentry-samples/sentry-samples-log4j2/build.gradle.kts
index 005e1116528..962fd56a839 100644
--- a/sentry-samples/sentry-samples-log4j2/build.gradle.kts
+++ b/sentry-samples/sentry-samples-log4j2/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.shadow)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.log4j2.Main") }
@@ -72,8 +73,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-logback/build.gradle.kts b/sentry-samples/sentry-samples-logback/build.gradle.kts
index 05f96c346a8..1a7f3a23875 100644
--- a/sentry-samples/sentry-samples-logback/build.gradle.kts
+++ b/sentry-samples/sentry-samples-logback/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.shadow)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.logback.Main") }
@@ -66,8 +67,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-7/build.gradle.kts b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
index e3300cd2841..3e108aabd1e 100644
--- a/sentry-samples/sentry-samples-spring-7/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
@@ -10,6 +10,7 @@ plugins {
   alias(libs.plugins.kotlin.spring)
   id("war")
   alias(libs.plugins.gretty)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.spring7.Main") }
@@ -77,8 +78,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
index 64ef57692c3..722788830f1 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-4"
@@ -90,8 +91,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
index e12b960e0fd..b9551ffcf74 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
@@ -7,6 +7,7 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-4"
@@ -110,6 +111,9 @@ tasks.register<BootRun>("bootRunWithAgent").configure {
   jvmArgs = listOf("-Dotel.javaagent.debug=true", "-javaagent:$agentJarPath")
 }
 
+// The runner launches this sample with -javaagent, so track the agent jar as a systemTest input.
+sentrySystemTest { usesOpenTelemetryAgent = true }
+
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
@@ -118,8 +122,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
index 7329d5cc0ea..d793201d4c0 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-4-otlp"
@@ -91,8 +92,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
index a311b8a972e..6d8d3c81e09 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-4-webflux"
@@ -70,8 +71,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
index cdb33ecc675..4e463671a78 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-4"
@@ -92,8 +93,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
index 7966e621ebd..553affc3620 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
@@ -7,6 +7,7 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-jakarta"
@@ -95,8 +96,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
index 3c7e00ae552..e4fefab7de7 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-jakarta"
@@ -120,6 +121,9 @@ tasks.register<BootRun>("bootRunWithAgent").configure {
   jvmArgs = listOf("-Dotel.javaagent.debug=true", "-javaagent:$agentJarPath")
 }
 
+// The runner launches this sample with -javaagent, so track the agent jar as a systemTest input.
+sentrySystemTest { usesOpenTelemetryAgent = true }
+
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
@@ -128,8 +132,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
index d5e4caa595d..65850a6f2bd 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
@@ -7,6 +7,7 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-jakarta"
@@ -98,8 +99,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
index 0b8c5a181e7..e32eec82ac8 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.shadow)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.spring.boot.SentryDemoApplication") }
@@ -140,8 +141,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
index b78f1f01881..085d6e362af 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.shadow)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.spring.boot.SentryDemoApplication") }
@@ -154,6 +155,9 @@ tasks.register<JavaExec>("bootRunWithAgent").configure {
   jvmArgs = listOf("-Dotel.javaagent.debug=true", "-javaagent:$agentJarPath")
 }
 
+// The runner launches this sample with -javaagent, so track the agent jar as a systemTest input.
+sentrySystemTest { usesOpenTelemetryAgent = true }
+
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
@@ -162,8 +166,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
index 8b2079ddd9c..3e462517ded 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
@@ -7,6 +7,7 @@ plugins {
   alias(libs.plugins.spring.dependency.management)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 group = "io.sentry.sample.spring-boot-webflux-jakarta"
@@ -72,8 +73,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
index 2127dbfd79f..8dc51e07a53 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.shadow)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.spring.boot.SentryDemoApplication") }
@@ -107,8 +108,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
index 0a2a6f2da57..54fe99d56d4 100644
--- a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.shadow)
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.kotlin.spring)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.spring.boot.SentryDemoApplication") }
@@ -141,8 +142,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
index 3dec793e5c9..5fe0334a629 100644
--- a/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.kotlin.spring)
   id("war")
   alias(libs.plugins.gretty)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.spring.jakarta.Main") }
@@ -77,8 +78,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test
diff --git a/sentry-samples/sentry-samples-spring/build.gradle.kts b/sentry-samples/sentry-samples-spring/build.gradle.kts
index 02e7f632450..3ab6610d96d 100644
--- a/sentry-samples/sentry-samples-spring/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.kotlin.spring)
   id("war")
   alias(libs.plugins.gretty)
+  id("io.sentry.systemtest")
 }
 
 application { mainClass.set("io.sentry.samples.spring.Main") }
@@ -78,8 +79,6 @@ tasks.register<Test>("systemTest").configure {
   testClassesDirs = test.output.classesDirs
   classpath = test.runtimeClasspath
 
-  outputs.upToDateWhen { false }
-
   maxParallelForks = 1
 
   // Cap JVM args per test

From ec5e3a55656fea8e4eec6aeff74a211df4894a6d Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Tue, 23 Jun 2026 20:09:38 +0200
Subject: [PATCH 225/391] fix(android): Fix crash when
 getHistoricalProcessStartReasons is called from a wrong process (#5597)

* fix(android): Fix crash when getHistoricalProcessStartReasons is called from a wrong process

* test(android): Add test and changelog for getHistoricalProcessStartReasons crash fix

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* SecurityException -> RuntimeException

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../core/performance/AppStartMetrics.java     | 31 +++++++++++++------
 .../core/SentryShadowActivityManager.kt       |  7 +++++
 .../performance/AppStartMetricsTestApi35.kt   | 14 +++++++++
 4 files changed, 43 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8d66d755a7c..0c3574f1fa6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Fix crash when `getHistoricalProcessStartReasons` is called from an isolated or wrong-userId process ([#5597](https://github.com/getsentry/sentry-java/pull/5597))
 - Release `MediaMuxer` when a replay segment has no encodable frames to avoid a resource leak ([#5583](https://github.com/getsentry/sentry-java/pull/5583))
 
 ## 8.44.1
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
index 36cae8686ca..828e103e8b6 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
@@ -11,6 +11,7 @@
 import android.os.Handler;
 import android.os.Looper;
 import android.os.SystemClock;
+import android.util.Log;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
@@ -467,18 +468,28 @@ public void registerLifecycleCallbacks(final @NotNull Application application) {
       final @Nullable ActivityManager activityManager =
           (ActivityManager) application.getSystemService(Context.ACTIVITY_SERVICE);
       if (activityManager != null) {
-        final List<ApplicationStartInfo> historicalProcessStartReasons =
-            activityManager.getHistoricalProcessStartReasons(1);
-        if (!historicalProcessStartReasons.isEmpty()) {
-          final @NotNull ApplicationStartInfo info = historicalProcessStartReasons.get(0);
-          cachedStartInfo = info;
-          if (info.getStartupState() == ApplicationStartInfo.STARTUP_STATE_STARTED) {
-            if (info.getStartType() == ApplicationStartInfo.START_TYPE_COLD) {
-              appStartType = AppStartType.COLD;
-            } else {
-              appStartType = AppStartType.WARM;
+        try {
+          final List<ApplicationStartInfo> historicalProcessStartReasons =
+              activityManager.getHistoricalProcessStartReasons(1);
+          if (!historicalProcessStartReasons.isEmpty()) {
+            final @NotNull ApplicationStartInfo info = historicalProcessStartReasons.get(0);
+            cachedStartInfo = info;
+            if (info.getStartupState() == ApplicationStartInfo.STARTUP_STATE_STARTED) {
+              if (info.getStartType() == ApplicationStartInfo.START_TYPE_COLD) {
+                appStartType = AppStartType.COLD;
+              } else {
+                appStartType = AppStartType.WARM;
+              }
             }
           }
+        } catch (RuntimeException ignored) {
+          // getHistoricalProcessStartReasons may throw different kinds of exceptions, namely:
+          // - SecurityException when called from an isolated process
+          // - IllegalArgumentException when called with a wrong userId
+          // - others
+          // See impl:
+          // https://cs.android.com/android/platform/superproject/+/android-latest-release:frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java;l=10866-10893
+          Log.w("AppStartMetrics", ignored); // no logger instance here, so we just Log
         }
       }
     }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowActivityManager.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowActivityManager.kt
index a959c5dd865..93cb4759e99 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowActivityManager.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryShadowActivityManager.kt
@@ -12,11 +12,16 @@ class SentryShadowActivityManager {
   companion object {
     private var historicalProcessStartReasons: List<ApplicationStartInfo> = emptyList()
     private var importance: Int = RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+    private var historicalProcessStartReasonsException: RuntimeException? = null
 
     fun setHistoricalProcessStartReasons(startReasons: List<ApplicationStartInfo>) {
       historicalProcessStartReasons = startReasons
     }
 
+    fun setHistoricalProcessStartReasonsException(exception: RuntimeException) {
+      historicalProcessStartReasonsException = exception
+    }
+
     fun setImportance(importance: Int) {
       this.importance = importance
     }
@@ -24,6 +29,7 @@ class SentryShadowActivityManager {
     fun reset() {
       historicalProcessStartReasons = emptyList()
       importance = RunningAppProcessInfo.IMPORTANCE_FOREGROUND
+      historicalProcessStartReasonsException = null
     }
 
     @Implementation
@@ -35,6 +41,7 @@ class SentryShadowActivityManager {
 
   @Implementation
   fun getHistoricalProcessStartReasons(maxNum: Int): List<ApplicationStartInfo> {
+    historicalProcessStartReasonsException?.let { throw it }
     return historicalProcessStartReasons.take(maxNum)
   }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
index b5d87ab77cb..0624e70b898 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
@@ -249,6 +249,20 @@ class AppStartMetricsTestApi35 {
     assertNull(metrics.appStartReason)
   }
 
+  @Test
+  fun `does not crash when getHistoricalProcessStartReasons throws RuntimeException`() {
+    SentryShadowActivityManager.setHistoricalProcessStartReasonsException(
+      RuntimeException("isolated process")
+    )
+    val metrics = AppStartMetrics.getInstance()
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    assertEquals(AppStartMetrics.AppStartType.UNKNOWN, metrics.appStartType)
+    assertNull(metrics.appStartReason)
+  }
+
   private fun waitForMainLooperIdle() {
     Handler(Looper.getMainLooper()).post {}
     Shadows.shadowOf(Looper.getMainLooper()).idle()

From 818350078b0238d8db99964f3464614643490fa5 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 24 Jun 2026 13:23:23 +0200
Subject: [PATCH 226/391] fix(replay): Fix flaky ComposeMaskingOptionsTest
 (#5613)

The `when sentry-unmask modifier is set unmasks the node` test intermittently
failed because Robolectric can report zero bounds for some nodes when running
the full test class, making them invisible (shouldMask = isVisible && ...).

Restructure the test to:
- Explicitly find the "Make Request" node and assert it IS visible and unmasked
- Assert other visible nodes remain masked, with a guard against empty iteration
- Tolerate intermittent zero-bounds on non-identifiable nodes (Robolectric artifact)

Validated with the repro from getsentry/repro#51: 20/20 passes (vs ~10% flake
rate before the fix).

Fixes #5585

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../ComposeMaskingOptionsTest.kt              | 28 +++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
index e043b035668..fe3fbc1ba67 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
@@ -228,18 +228,24 @@ class ComposeMaskingOptionsTest {
 
     val textNodes = activity.get().collectNodesOfType<TextViewHierarchyNode>(options)
     assertEquals(4, textNodes.size) // [TextField, Text, Button, Activity Title]
-    textNodes.forEach {
-      if ((it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text == "Make Request") {
-        assertFalse(
-          it.shouldMask,
-          "Node with text ${(it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text} should not be masked",
-        )
-      } else {
-        assertTrue(
-          it.shouldMask,
-          "Node with text ${(it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text} should be masked",
-        )
+
+    val unmaskNode =
+      textNodes.first {
+        (it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text == "Make Request"
       }
+    assertTrue(unmaskNode.isVisible, "The unmasked node must be visible for the test to be valid")
+    assertFalse(unmaskNode.shouldMask, "Node with sentryReplayUnmask() should not be masked")
+
+    // Robolectric may intermittently report zero bounds for some nodes when running
+    // the full test class, making them invisible (shouldMask = isVisible && ...).
+    // Assert that all other visible nodes remain masked.
+    val otherVisibleNodes = textNodes.filter { it !== unmaskNode && it.isVisible }
+    assertTrue(otherVisibleNodes.isNotEmpty(), "Expected at least one other visible text node")
+    otherVisibleNodes.forEach {
+      assertTrue(
+        it.shouldMask,
+        "Node with text ${(it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text} should be masked",
+      )
     }
   }
 

From 3c89fa4c79a2af40618acffcdc84f9a98eb4aca8 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 24 Jun 2026 14:33:54 +0200
Subject: [PATCH 227/391] ci(replay): Skip snapshot upload on PRs from forks
 (#5621)

Fork PRs don't have access to the SENTRY_AUTH_TOKEN secret, so the
sentry-cli snapshot upload would fail anyway. Guard the step to run
only on pushes and same-repo PRs.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/workflows/integration-tests-ui.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 92e29ecbef7..e271227b97e 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -78,7 +78,8 @@ jobs:
         run: curl -sL https://sentry.io/get-cli/ | bash
 
       - name: Upload Replay Snapshots to Sentry
-        if: ${{ !cancelled() && env.SAUCE_USERNAME != null }}
+        # Skip on PRs from forks, which don't have access to the upload secret
+        if: ${{ !cancelled() && env.SAUCE_USERNAME != null && (github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository) }}
         run: |
           shopt -s globstar nullglob
           pngs=(artifacts/**/*.png)

From 477b848f9ad9a2eac9efa22553ca3da49cf0ab68 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 24 Jun 2026 16:44:37 +0200
Subject: [PATCH 228/391] ci(build): Skip snapshot upload on PRs from forks
 (#5622)

Fork PRs don't have access to SENTRY_AUTH_TOKEN, so the upload step
would attempt to run without credentials. Guard it the same way the
replay snapshot upload is guarded so fork PRs cleanly skip it.
---
 .github/workflows/build.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index f2ffd96f9c5..6cba7e07e0a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -49,6 +49,8 @@ jobs:
         run: curl -sL https://sentry.io/get-cli/ | bash
 
       - name: Upload Snapshots to Sentry
+        # Skip on PRs from forks, which don't have access to the upload secret
+        if: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository }}
         run: |
           sentry-cli build snapshots ./sentry-android-core/build/test-snapshots \
             --app-id sentry-android-core

From 693fc159de6b16dff56436c11b55543111b4d207 Mon Sep 17 00:00:00 2001
From: tsushanth <78000697+tsushanth@users.noreply.github.com>
Date: Wed, 24 Jun 2026 08:01:18 -0700
Subject: [PATCH 229/391] fix: use System.nanoTime() for cron check-in duration
 measurement (#5611)

* fix: use System.nanoTime() for cron check-in duration measurement

System.currentTimeMillis() is a wall-clock value and is subject to
NTP adjustments and DST transitions. For long-running cron jobs this
can produce incorrect or even negative durations in the check-in payload.

Switch the start/end capture in CheckInUtils.withCheckIn() and the three
SentryCheckInAdvice implementations (sentry-spring, sentry-spring-jakarta,
sentry-spring-7) to System.nanoTime(), which is guaranteed monotonic.
Use DateUtils.nanosToSeconds() (already present) to convert the delta.

Fixes #5579

* changelog

---------

Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 CHANGELOG.md                                                  | 1 +
 .../java/io/sentry/spring7/checkin/SentryCheckInAdvice.java   | 4 ++--
 .../io/sentry/spring/jakarta/checkin/SentryCheckInAdvice.java | 4 ++--
 .../java/io/sentry/spring/checkin/SentryCheckInAdvice.java    | 4 ++--
 sentry/src/main/java/io/sentry/util/CheckInUtils.java         | 4 ++--
 5 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0c3574f1fa6..5a01e722486 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Use `System.nanoTime()` for cron check-in duration measurement to avoid incorrect durations from wall-clock adjustments ([#5611](https://github.com/getsentry/sentry-java/pull/5611))
 - Fix crash when `getHistoricalProcessStartReasons` is called from an isolated or wrong-userId process ([#5597](https://github.com/getsentry/sentry-java/pull/5597))
 - Release `MediaMuxer` when a replay segment has no encodable frames to avoid a resource leak ([#5583](https://github.com/getsentry/sentry-java/pull/5583))
 
diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryCheckInAdvice.java b/sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryCheckInAdvice.java
index 274c20ac89a..d2c164b9a6e 100644
--- a/sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryCheckInAdvice.java
+++ b/sentry-spring-7/src/main/java/io/sentry/spring7/checkin/SentryCheckInAdvice.java
@@ -91,7 +91,7 @@ public Object invoke(final @NotNull MethodInvocation invocation) throws Throwabl
       TracingUtils.startNewTrace(scopes);
 
       @Nullable SentryId checkInId = null;
-      final long startTime = System.currentTimeMillis();
+      final long startTime = System.nanoTime();
       boolean didError = false;
 
       try {
@@ -105,7 +105,7 @@ public Object invoke(final @NotNull MethodInvocation invocation) throws Throwabl
       } finally {
         final @NotNull CheckInStatus status = didError ? CheckInStatus.ERROR : CheckInStatus.OK;
         CheckIn checkIn = new CheckIn(checkInId, monitorSlug, status);
-        checkIn.setDuration(DateUtils.millisToSeconds(System.currentTimeMillis() - startTime));
+        checkIn.setDuration(DateUtils.nanosToSeconds(System.nanoTime() - startTime));
         scopes.captureCheckIn(checkIn);
       }
     }
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/checkin/SentryCheckInAdvice.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/checkin/SentryCheckInAdvice.java
index d2b93471f1c..fa64ac0e3e4 100644
--- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/checkin/SentryCheckInAdvice.java
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/checkin/SentryCheckInAdvice.java
@@ -91,7 +91,7 @@ public Object invoke(final @NotNull MethodInvocation invocation) throws Throwabl
       TracingUtils.startNewTrace(scopes);
 
       @Nullable SentryId checkInId = null;
-      final long startTime = System.currentTimeMillis();
+      final long startTime = System.nanoTime();
       boolean didError = false;
 
       try {
@@ -105,7 +105,7 @@ public Object invoke(final @NotNull MethodInvocation invocation) throws Throwabl
       } finally {
         final @NotNull CheckInStatus status = didError ? CheckInStatus.ERROR : CheckInStatus.OK;
         CheckIn checkIn = new CheckIn(checkInId, monitorSlug, status);
-        checkIn.setDuration(DateUtils.millisToSeconds(System.currentTimeMillis() - startTime));
+        checkIn.setDuration(DateUtils.nanosToSeconds(System.nanoTime() - startTime));
         scopes.captureCheckIn(checkIn);
       }
     }
diff --git a/sentry-spring/src/main/java/io/sentry/spring/checkin/SentryCheckInAdvice.java b/sentry-spring/src/main/java/io/sentry/spring/checkin/SentryCheckInAdvice.java
index 719ead46b51..a96e9e29808 100644
--- a/sentry-spring/src/main/java/io/sentry/spring/checkin/SentryCheckInAdvice.java
+++ b/sentry-spring/src/main/java/io/sentry/spring/checkin/SentryCheckInAdvice.java
@@ -94,7 +94,7 @@ public Object invoke(final @NotNull MethodInvocation invocation) throws Throwabl
       TracingUtils.startNewTrace(scopes);
 
       @Nullable SentryId checkInId = null;
-      final long startTime = System.currentTimeMillis();
+      final long startTime = System.nanoTime();
       boolean didError = false;
 
       try {
@@ -108,7 +108,7 @@ public Object invoke(final @NotNull MethodInvocation invocation) throws Throwabl
       } finally {
         final @NotNull CheckInStatus status = didError ? CheckInStatus.ERROR : CheckInStatus.OK;
         CheckIn checkIn = new CheckIn(checkInId, monitorSlug, status);
-        checkIn.setDuration(DateUtils.millisToSeconds(System.currentTimeMillis() - startTime));
+        checkIn.setDuration(DateUtils.nanosToSeconds(System.nanoTime() - startTime));
         scopes.captureCheckIn(checkIn);
       }
     }
diff --git a/sentry/src/main/java/io/sentry/util/CheckInUtils.java b/sentry/src/main/java/io/sentry/util/CheckInUtils.java
index 7b44fffbc35..3deea093142 100644
--- a/sentry/src/main/java/io/sentry/util/CheckInUtils.java
+++ b/sentry/src/main/java/io/sentry/util/CheckInUtils.java
@@ -37,7 +37,7 @@ public static <U> U withCheckIn(
     try (final @NotNull ISentryLifecycleToken ignored =
             Sentry.forkedScopes("CheckInUtils").makeCurrent()) {
       final @NotNull IScopes scopes = Sentry.getCurrentScopes();
-      final long startTime = System.currentTimeMillis();
+      final long startTime = System.nanoTime();
       boolean didError = false;
 
       TracingUtils.startNewTrace(scopes);
@@ -61,7 +61,7 @@ public static <U> U withCheckIn(
         if (environment != null) {
           checkIn.setEnvironment(environment);
         }
-        checkIn.setDuration(DateUtils.millisToSeconds(System.currentTimeMillis() - startTime));
+        checkIn.setDuration(DateUtils.nanosToSeconds(System.nanoTime() - startTime));
         scopes.captureCheckIn(checkIn);
       }
     }

From 0499903a71e617bd84b2f748b25f7ca2db71f134 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 24 Jun 2026 17:26:29 +0200
Subject: [PATCH 230/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.15.2 (#5610)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 ++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5a01e722486..596c36b3320 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,12 @@
 - Fix crash when `getHistoricalProcessStartReasons` is called from an isolated or wrong-userId process ([#5597](https://github.com/getsentry/sentry-java/pull/5597))
 - Release `MediaMuxer` when a replay segment has no encodable frames to avoid a resource leak ([#5583](https://github.com/getsentry/sentry-java/pull/5583))
 
+### Dependencies
+
+- Bump Native SDK from v0.15.1 to v0.15.2 ([#5610](https://github.com/getsentry/sentry-java/pull/5610))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0152)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.15.1...0.15.2)
+
 ## 8.44.1
 
 ### Fixes
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 68521efdfcc..24064703ca1 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -166,7 +166,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.1" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.2" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From f8e292e692fee3774289917409f05080b443bec3 Mon Sep 17 00:00:00 2001
From: 0xadam-brown <281682121+0xadam-brown@users.noreply.github.com>
Date: Wed, 24 Jun 2026 15:30:08 +0000
Subject: [PATCH 231/391] release: 8.45.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 596c36b3320..e1a4d05122c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.45.0
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index f2e3da3ca09..f83b851f8d9 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.44.1
+versionName=8.45.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 2c01eff3d05e76446bc1264d9235077ce183fee6 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 24 Jun 2026 18:50:01 +0200
Subject: [PATCH 232/391] fix(changelog): Move app start reason to 8.45.0
 (#5625)

---
 CHANGELOG.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e1a4d05122c..48a1115f8ae 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## 8.45.0
 
+### Features
+
+- On Android 15+ (API 35), the standalone `app.start` transaction now reports why the OS started the process via `app.vitals.start.reason` trace data (e.g. `launcher`, `broadcast`, `service`, `content_provider`), derived from `ApplicationStartInfo.getReason()`. You can search and group by this attribute in the Trace Explorer. ([#5552](https://github.com/getsentry/sentry-java/pull/5552))
+
 ### Fixes
 
 - Use `System.nanoTime()` for cron check-in duration measurement to avoid incorrect durations from wall-clock adjustments ([#5611](https://github.com/getsentry/sentry-java/pull/5611))
@@ -41,7 +45,6 @@
   - Emits a transaction named `App Start` with op `app.start`, carrying the existing app start measurements and phase spans (`process.load`, `contentprovider.load`, `application.load`, activity lifecycle spans) as direct children of the root
   - The standalone transaction shares the same `traceId` as the first `ui.load` activity transaction so they remain linked in the trace view
   - Also covers non-activity starts (broadcast receivers, services, content providers)
-  - On Android 15+ (API 35), the standalone `app.start` transaction reports why the OS started the process via `app.vitals.start.reason` trace data (e.g. `launcher`, `broadcast`, `service`, `content_provider`), derived from `ApplicationStartInfo.getReason()`. You can search and group by this attribute in the Trace Explorer. ([#5552](https://github.com/getsentry/sentry-java/pull/5552))
 
 ### Improvements
 

From 6424f21f3573988056d194317e654ef11d605426 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 25 Jun 2026 10:50:50 +0200
Subject: [PATCH 233/391] build: Remove redundant test source set declarations
 (#5624)

The line configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
re-added Gradle's default test source directory, which is a no-op. Remove it
from all 51 build files.
---
 sentry-apache-http-client-5/build.gradle.kts                    | 2 --
 sentry-apollo-3/build.gradle.kts                                | 2 --
 sentry-apollo-4/build.gradle.kts                                | 2 --
 sentry-apollo/build.gradle.kts                                  | 2 --
 sentry-async-profiler/build.gradle.kts                          | 2 --
 sentry-graphql-22/build.gradle.kts                              | 2 --
 sentry-graphql-core/build.gradle.kts                            | 2 --
 sentry-graphql/build.gradle.kts                                 | 2 --
 sentry-jcache/build.gradle.kts                                  | 2 --
 sentry-jdbc/build.gradle.kts                                    | 2 --
 sentry-jul/build.gradle.kts                                     | 2 --
 sentry-kafka/build.gradle.kts                                   | 2 --
 sentry-kotlin-extensions/build.gradle.kts                       | 2 --
 sentry-ktor-client/build.gradle.kts                             | 2 --
 sentry-launchdarkly-server/build.gradle.kts                     | 2 --
 sentry-log4j2/build.gradle.kts                                  | 2 --
 sentry-logback/build.gradle.kts                                 | 2 --
 sentry-okhttp/build.gradle.kts                                  | 2 --
 sentry-openfeature/build.gradle.kts                             | 2 --
 sentry-openfeign/build.gradle.kts                               | 2 --
 .../sentry-opentelemetry-agentcustomization/build.gradle.kts    | 2 --
 .../sentry-opentelemetry-bootstrap/build.gradle.kts             | 2 --
 sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts | 2 --
 sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts | 2 --
 sentry-quartz/build.gradle.kts                                  | 2 --
 sentry-reactor/build.gradle.kts                                 | 2 --
 .../build.gradle.kts                                            | 2 --
 sentry-samples/sentry-samples-console-otlp/build.gradle.kts     | 2 --
 sentry-samples/sentry-samples-console/build.gradle.kts          | 2 --
 sentry-samples/sentry-samples-jul/build.gradle.kts              | 2 --
 sentry-samples/sentry-samples-log4j2/build.gradle.kts           | 2 --
 sentry-samples/sentry-samples-logback/build.gradle.kts          | 2 --
 sentry-samples/sentry-samples-spring-7/build.gradle.kts         | 2 --
 .../build.gradle.kts                                            | 2 --
 .../sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts | 2 --
 .../sentry-samples-spring-boot-4-otlp/build.gradle.kts          | 2 --
 .../sentry-samples-spring-boot-4-webflux/build.gradle.kts       | 2 --
 sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts    | 2 --
 sentry-servlet-jakarta/build.gradle.kts                         | 2 --
 sentry-servlet/build.gradle.kts                                 | 2 --
 sentry-spotlight/build.gradle.kts                               | 2 --
 sentry-spring-7/build.gradle.kts                                | 2 --
 sentry-spring-boot-4-starter/build.gradle.kts                   | 2 --
 sentry-spring-boot-4/build.gradle.kts                           | 2 --
 sentry-spring-boot-jakarta/build.gradle.kts                     | 2 --
 sentry-spring-boot-starter-jakarta/build.gradle.kts             | 2 --
 sentry-spring-boot-starter/build.gradle.kts                     | 2 --
 sentry-spring-jakarta/build.gradle.kts                          | 2 --
 sentry-system-test-support/build.gradle.kts                     | 2 --
 sentry-test-support/build.gradle.kts                            | 2 --
 sentry/build.gradle.kts                                         | 2 --
 51 files changed, 102 deletions(-)

diff --git a/sentry-apache-http-client-5/build.gradle.kts b/sentry-apache-http-client-5/build.gradle.kts
index df93fbe8823..00916258b8f 100644
--- a/sentry-apache-http-client-5/build.gradle.kts
+++ b/sentry-apache-http-client-5/build.gradle.kts
@@ -33,8 +33,6 @@ dependencies {
   testImplementation(libs.mockito.kotlin)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-apollo-3/build.gradle.kts b/sentry-apollo-3/build.gradle.kts
index 1eb71bc217a..d70085e27bd 100644
--- a/sentry-apollo-3/build.gradle.kts
+++ b/sentry-apollo-3/build.gradle.kts
@@ -42,8 +42,6 @@ dependencies {
   signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks { check { dependsOn(animalsnifferMain) } }
 
 tasks.withType<JavaCompile>().configureEach {
diff --git a/sentry-apollo-4/build.gradle.kts b/sentry-apollo-4/build.gradle.kts
index 144297ddb9d..d9f41891dc1 100644
--- a/sentry-apollo-4/build.gradle.kts
+++ b/sentry-apollo-4/build.gradle.kts
@@ -49,8 +49,6 @@ dependencies {
   signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks { check { dependsOn(animalsnifferMain) } }
 
 tasks.withType<JavaCompile>().configureEach {
diff --git a/sentry-apollo/build.gradle.kts b/sentry-apollo/build.gradle.kts
index c115e6b8fe3..0fc853886df 100644
--- a/sentry-apollo/build.gradle.kts
+++ b/sentry-apollo/build.gradle.kts
@@ -43,8 +43,6 @@ dependencies {
   signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks { check { dependsOn(animalsnifferMain) } }
 
 tasks.withType<JavaCompile>().configureEach {
diff --git a/sentry-async-profiler/build.gradle.kts b/sentry-async-profiler/build.gradle.kts
index ef000b465a1..17093fe6a09 100644
--- a/sentry-async-profiler/build.gradle.kts
+++ b/sentry-async-profiler/build.gradle.kts
@@ -36,8 +36,6 @@ dependencies {
   testImplementation(libs.mockito.inline)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-graphql-22/build.gradle.kts b/sentry-graphql-22/build.gradle.kts
index c36ca09856d..3c0667fd0d4 100644
--- a/sentry-graphql-22/build.gradle.kts
+++ b/sentry-graphql-22/build.gradle.kts
@@ -41,8 +41,6 @@ dependencies {
   testImplementation("com.netflix.graphql.dgs:graphql-error-types:4.9.2")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-graphql-core/build.gradle.kts b/sentry-graphql-core/build.gradle.kts
index d625c31dea6..62635ded34e 100644
--- a/sentry-graphql-core/build.gradle.kts
+++ b/sentry-graphql-core/build.gradle.kts
@@ -40,8 +40,6 @@ dependencies {
   testImplementation("com.netflix.graphql.dgs:graphql-error-types:4.9.2")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-graphql/build.gradle.kts b/sentry-graphql/build.gradle.kts
index 68efbc7389e..30000655079 100644
--- a/sentry-graphql/build.gradle.kts
+++ b/sentry-graphql/build.gradle.kts
@@ -41,8 +41,6 @@ dependencies {
   testImplementation("com.netflix.graphql.dgs:graphql-error-types:4.9.2")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-jcache/build.gradle.kts b/sentry-jcache/build.gradle.kts
index 2c476dbd007..1cc3b6e0e3d 100644
--- a/sentry-jcache/build.gradle.kts
+++ b/sentry-jcache/build.gradle.kts
@@ -36,8 +36,6 @@ dependencies {
   testImplementation(libs.mockito.inline)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-jdbc/build.gradle.kts b/sentry-jdbc/build.gradle.kts
index 8a7808530b1..1e86048053e 100644
--- a/sentry-jdbc/build.gradle.kts
+++ b/sentry-jdbc/build.gradle.kts
@@ -34,8 +34,6 @@ dependencies {
   testImplementation(libs.mockito.inline)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-jul/build.gradle.kts b/sentry-jul/build.gradle.kts
index b59a1481d19..66c46bcee21 100644
--- a/sentry-jul/build.gradle.kts
+++ b/sentry-jul/build.gradle.kts
@@ -33,8 +33,6 @@ dependencies {
   testImplementation(libs.slf4j.api)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks {
   test {
     // used to test io.sentry.jul.SentryHandler
diff --git a/sentry-kafka/build.gradle.kts b/sentry-kafka/build.gradle.kts
index 603014f9af9..ef1ff252468 100644
--- a/sentry-kafka/build.gradle.kts
+++ b/sentry-kafka/build.gradle.kts
@@ -33,8 +33,6 @@ dependencies {
   testImplementation(libs.kafka.clients)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-kotlin-extensions/build.gradle.kts b/sentry-kotlin-extensions/build.gradle.kts
index 5092976de32..8c4312641a8 100644
--- a/sentry-kotlin-extensions/build.gradle.kts
+++ b/sentry-kotlin-extensions/build.gradle.kts
@@ -37,8 +37,6 @@ dependencies {
   signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks { check { dependsOn(animalsnifferMain) } }
 
 tasks.withType<Detekt>().configureEach {
diff --git a/sentry-ktor-client/build.gradle.kts b/sentry-ktor-client/build.gradle.kts
index 745acaa11fb..647563cc1d1 100644
--- a/sentry-ktor-client/build.gradle.kts
+++ b/sentry-ktor-client/build.gradle.kts
@@ -44,8 +44,6 @@ dependencies {
   signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks { check { dependsOn(animalsnifferMain) } }
 
 buildConfig {
diff --git a/sentry-launchdarkly-server/build.gradle.kts b/sentry-launchdarkly-server/build.gradle.kts
index 207400676a0..370252c2154 100644
--- a/sentry-launchdarkly-server/build.gradle.kts
+++ b/sentry-launchdarkly-server/build.gradle.kts
@@ -37,8 +37,6 @@ dependencies {
   testImplementation(libs.launchdarkly.server)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-log4j2/build.gradle.kts b/sentry-log4j2/build.gradle.kts
index 7d406076e2f..1c5cf94e8eb 100644
--- a/sentry-log4j2/build.gradle.kts
+++ b/sentry-log4j2/build.gradle.kts
@@ -35,8 +35,6 @@ dependencies {
   testImplementation(libs.mockito.kotlin)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.log4j2")
diff --git a/sentry-logback/build.gradle.kts b/sentry-logback/build.gradle.kts
index d2084e95467..1c42a4e1c03 100644
--- a/sentry-logback/build.gradle.kts
+++ b/sentry-logback/build.gradle.kts
@@ -32,8 +32,6 @@ dependencies {
   testImplementation(libs.mockito.kotlin)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.logback")
diff --git a/sentry-okhttp/build.gradle.kts b/sentry-okhttp/build.gradle.kts
index ea831f174cc..d547720c174 100644
--- a/sentry-okhttp/build.gradle.kts
+++ b/sentry-okhttp/build.gradle.kts
@@ -43,8 +43,6 @@ dependencies {
   signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks { check { dependsOn(animalsnifferMain) } }
 
 buildConfig {
diff --git a/sentry-openfeature/build.gradle.kts b/sentry-openfeature/build.gradle.kts
index 5847f48e7b5..fbabcb81aa5 100644
--- a/sentry-openfeature/build.gradle.kts
+++ b/sentry-openfeature/build.gradle.kts
@@ -37,8 +37,6 @@ dependencies {
   testImplementation(libs.openfeature)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-openfeign/build.gradle.kts b/sentry-openfeign/build.gradle.kts
index e9e3a2b18de..9b1ac2bbc29 100644
--- a/sentry-openfeign/build.gradle.kts
+++ b/sentry-openfeign/build.gradle.kts
@@ -34,8 +34,6 @@ dependencies {
   testImplementation(libs.okhttp.mockwebserver)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts
index ed6605f8da4..71f31ce2afb 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts
@@ -40,8 +40,6 @@ dependencies {
   testImplementation(libs.mockito.kotlin)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
index 503c92c95f0..d4bd1af9ede 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
@@ -35,8 +35,6 @@ dependencies {
   testImplementation(libs.otel.semconv.incubating)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
index 5b3b9d97ff4..91ec023e178 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
@@ -45,8 +45,6 @@ dependencies {
   testImplementation(libs.otel.semconv.incubating)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
index 21e75c0ed7d..d63c8a5c451 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
@@ -41,8 +41,6 @@ dependencies {
   //  testImplementation(libs.otel.semconv.incubating)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-quartz/build.gradle.kts b/sentry-quartz/build.gradle.kts
index 69c0e72ee07..6e227abafe6 100644
--- a/sentry-quartz/build.gradle.kts
+++ b/sentry-quartz/build.gradle.kts
@@ -35,8 +35,6 @@ dependencies {
   testImplementation(libs.mockito.inline)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-reactor/build.gradle.kts b/sentry-reactor/build.gradle.kts
index 4d389b0a334..07024b3a23b 100644
--- a/sentry-reactor/build.gradle.kts
+++ b/sentry-reactor/build.gradle.kts
@@ -43,8 +43,6 @@ dependencies {
   testImplementation("org.junit.jupiter:junit-jupiter")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.reactor")
diff --git a/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
index 9db90129958..23df981060f 100644
--- a/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
@@ -62,8 +62,6 @@ tasks.jar {
 // Fix the startScripts task dependency
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-console-otlp/build.gradle.kts b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
index 261894baaa0..9bb0678bf65 100644
--- a/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
@@ -65,8 +65,6 @@ tasks.jar {
 // Fix the startScripts task dependency
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-console/build.gradle.kts b/sentry-samples/sentry-samples-console/build.gradle.kts
index 3e70e79ae71..8fdef6ef70e 100644
--- a/sentry-samples/sentry-samples-console/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console/build.gradle.kts
@@ -66,8 +66,6 @@ tasks.jar {
 // Fix the startScripts task dependency
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-jul/build.gradle.kts b/sentry-samples/sentry-samples-jul/build.gradle.kts
index 310af1e7bce..5381f3ff2f0 100644
--- a/sentry-samples/sentry-samples-jul/build.gradle.kts
+++ b/sentry-samples/sentry-samples-jul/build.gradle.kts
@@ -57,8 +57,6 @@ tasks.jar {
 // Fix the startScripts task dependency
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-log4j2/build.gradle.kts b/sentry-samples/sentry-samples-log4j2/build.gradle.kts
index 962fd56a839..07df6703c85 100644
--- a/sentry-samples/sentry-samples-log4j2/build.gradle.kts
+++ b/sentry-samples/sentry-samples-log4j2/build.gradle.kts
@@ -63,8 +63,6 @@ tasks.jar {
 // Fix the startScripts task dependency
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-logback/build.gradle.kts b/sentry-samples/sentry-samples-logback/build.gradle.kts
index 1a7f3a23875..bb37638d8c5 100644
--- a/sentry-samples/sentry-samples-logback/build.gradle.kts
+++ b/sentry-samples/sentry-samples-logback/build.gradle.kts
@@ -57,8 +57,6 @@ tasks.jar {
 // Fix the startScripts task dependency
 tasks.startScripts { dependsOn(tasks.shadowJar) }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-spring-7/build.gradle.kts b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
index 3e108aabd1e..6de7ed62e9f 100644
--- a/sentry-samples/sentry-samples-spring-7/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
@@ -68,8 +68,6 @@ tasks.withType<KotlinCompile>().configureEach {
   }
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
index 722788830f1..afdb92e5c5b 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
@@ -81,8 +81,6 @@ dependencies {
 
 dependencyManagement { imports { mavenBom(libs.otel.instrumentation.bom.get().toString()) } }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
index b9551ffcf74..f0e2d468fec 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
@@ -84,8 +84,6 @@ dependencies {
   testImplementation("ch.qos.logback:logback-core:1.5.16")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<BootRun>("bootRunWithAgent").configure {
   group = "application"
 
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
index d793201d4c0..d7c2c009bc9 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
@@ -82,8 +82,6 @@ dependencies {
 
 dependencyManagement { imports { mavenBom(libs.otel.instrumentation.bom.get().toString()) } }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
index 6d8d3c81e09..20ccf2d662c 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
@@ -49,8 +49,6 @@ dependencies {
   testImplementation("ch.qos.logback:logback-core:1.5.16")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<KotlinCompile>().configureEach {
   kotlin {
     explicitApi()
diff --git a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
index 4e463671a78..2cc1f34b9eb 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
@@ -83,8 +83,6 @@ dependencies {
   testImplementation("ch.qos.logback:logback-core:1.5.16")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.register<Test>("systemTest").configure {
   group = "verification"
   description = "Runs the System tests"
diff --git a/sentry-servlet-jakarta/build.gradle.kts b/sentry-servlet-jakarta/build.gradle.kts
index 728e147dc9b..3cdc4772f18 100644
--- a/sentry-servlet-jakarta/build.gradle.kts
+++ b/sentry-servlet-jakarta/build.gradle.kts
@@ -35,8 +35,6 @@ dependencies {
   testImplementation(libs.servlet.jakarta.api)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-servlet/build.gradle.kts b/sentry-servlet/build.gradle.kts
index 142a1cd2f20..9f12d4ee177 100644
--- a/sentry-servlet/build.gradle.kts
+++ b/sentry-servlet/build.gradle.kts
@@ -36,8 +36,6 @@ dependencies {
   testImplementation(libs.springboot.starter.web)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-spotlight/build.gradle.kts b/sentry-spotlight/build.gradle.kts
index b034c8267db..71498aecd92 100644
--- a/sentry-spotlight/build.gradle.kts
+++ b/sentry-spotlight/build.gradle.kts
@@ -35,8 +35,6 @@ dependencies {
   signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks { check { dependsOn(animalsnifferMain) } }
 
 buildConfig {
diff --git a/sentry-spring-7/build.gradle.kts b/sentry-spring-7/build.gradle.kts
index ec90aedcbeb..4e5ea54d294 100644
--- a/sentry-spring-7/build.gradle.kts
+++ b/sentry-spring-7/build.gradle.kts
@@ -82,8 +82,6 @@ dependencies {
   testImplementation(projects.sentryReactor)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring7")
diff --git a/sentry-spring-boot-4-starter/build.gradle.kts b/sentry-spring-boot-4-starter/build.gradle.kts
index c0f655e965f..bffe53aab01 100644
--- a/sentry-spring-boot-4-starter/build.gradle.kts
+++ b/sentry-spring-boot-4-starter/build.gradle.kts
@@ -38,8 +38,6 @@ dependencies {
   errorprone(libs.nullaway)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-spring-boot-4/build.gradle.kts b/sentry-spring-boot-4/build.gradle.kts
index 43e105ad8db..2a6634b257f 100644
--- a/sentry-spring-boot-4/build.gradle.kts
+++ b/sentry-spring-boot-4/build.gradle.kts
@@ -108,8 +108,6 @@ dependencies {
   testImplementation(libs.springboot4.resttestclient)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring.boot4")
diff --git a/sentry-spring-boot-jakarta/build.gradle.kts b/sentry-spring-boot-jakarta/build.gradle.kts
index edd2d605916..1ed9373f4bf 100644
--- a/sentry-spring-boot-jakarta/build.gradle.kts
+++ b/sentry-spring-boot-jakarta/build.gradle.kts
@@ -100,8 +100,6 @@ dependencies {
   testImplementation(projects.sentryAsyncProfiler)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring.boot.jakarta")
diff --git a/sentry-spring-boot-starter-jakarta/build.gradle.kts b/sentry-spring-boot-starter-jakarta/build.gradle.kts
index d7d10b73b8c..c6fe511073e 100644
--- a/sentry-spring-boot-starter-jakarta/build.gradle.kts
+++ b/sentry-spring-boot-starter-jakarta/build.gradle.kts
@@ -38,8 +38,6 @@ dependencies {
   errorprone(libs.nullaway)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-spring-boot-starter/build.gradle.kts b/sentry-spring-boot-starter/build.gradle.kts
index 3ef4ac59379..f4da56179cb 100644
--- a/sentry-spring-boot-starter/build.gradle.kts
+++ b/sentry-spring-boot-starter/build.gradle.kts
@@ -30,8 +30,6 @@ dependencies {
   errorprone(libs.nullaway)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-spring-jakarta/build.gradle.kts b/sentry-spring-jakarta/build.gradle.kts
index b4a61129df7..f103bfcbe0a 100644
--- a/sentry-spring-jakarta/build.gradle.kts
+++ b/sentry-spring-jakarta/build.gradle.kts
@@ -77,8 +77,6 @@ dependencies {
   testImplementation(projects.sentryReactor)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spring.jakarta")
diff --git a/sentry-system-test-support/build.gradle.kts b/sentry-system-test-support/build.gradle.kts
index 4d4c7d5bb6e..7f08bf6d01b 100644
--- a/sentry-system-test-support/build.gradle.kts
+++ b/sentry-system-test-support/build.gradle.kts
@@ -41,8 +41,6 @@ dependencies {
   implementation(libs.mockito.kotlin)
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 apollo {
   service("service") {
     srcDir("src/main/graphql")
diff --git a/sentry-test-support/build.gradle.kts b/sentry-test-support/build.gradle.kts
index f108915d463..a0b508c9715 100644
--- a/sentry-test-support/build.gradle.kts
+++ b/sentry-test-support/build.gradle.kts
@@ -31,5 +31,3 @@ dependencies {
   implementation(libs.kotlin.test.junit)
   implementation(libs.mockito.kotlin)
 }
-
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
diff --git a/sentry/build.gradle.kts b/sentry/build.gradle.kts
index a2ecd281296..9717cb176ae 100644
--- a/sentry/build.gradle.kts
+++ b/sentry/build.gradle.kts
@@ -37,8 +37,6 @@ dependencies {
   signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-configure<SourceSetContainer> { test { java.srcDir("src/test/java") } }
-
 animalsniffer {
   ignore =
     listOf(

From d735888152fb47be1e04654e453e37febe3a0b9d Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Thu, 25 Jun 2026 12:04:33 +0200
Subject: [PATCH 234/391] chore(android-sqlite): Update SQLite instrumentation
 documentation after 8.45.0 release (#5572)

We'll be coordinating the 8.45.0 release with SAGP auto-instrumentation for the SentrySQLiteDriver. Commit contains related documentation updates.
---
 sentry-android-sqlite/README.md                        |  4 +++-
 .../main/java/io/sentry/sqlite/SentrySQLiteDriver.kt   | 10 ++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/sentry-android-sqlite/README.md b/sentry-android-sqlite/README.md
index 7bf9edf3474..307beb51f0e 100644
--- a/sentry-android-sqlite/README.md
+++ b/sentry-android-sqlite/README.md
@@ -4,11 +4,13 @@ SQLite instrumentation for AndroidX APIs.
 
 Two instrumentation paths are supported:
 
-- **`androidx.sqlite.SQLiteDriver`**: Used by Room 2.7+ and 3.0+.
+- **`androidx.sqlite.SQLiteDriver`**: Used by Room 2.7+ and 3.0+. Applied automatically by the Sentry Android Gradle Plugin.
 - **`androidx.sqlite.db.SupportSQLiteOpenHelper`**: Used by SQLDelight and legacy (pre-2.7) Room. Applied automatically by the Sentry Android Gradle Plugin.
 
 To avoid duplicate spans, only one path should be used per database file. Most Room and SQLDelight APIs enforce that division. The exception is Room's `SupportSQLiteDriver`: either the `SupportSQLiteOpenHelper` it consumes should be wrapped or the support driver itself, but never both.
 
+See the [SQLite integration docs](https://docs.sentry.io/platforms/android/integrations/room-and-sqlite/) for more details.
+
 ## Package layout
 
 The module is organized as two separate packages:
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
index 22f6353d883..4a616ba3abe 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
@@ -22,6 +22,9 @@ import org.jetbrains.annotations.ApiStatus
  *     .build()
  * ```
  *
+ * If you're using the Sentry Android Gradle Plugin (SAGP) 6.13.0+, wrapping will be performed
+ * automatically.
+ *
  * @param delegate The [SQLiteDriver] instance to delegate calls to.
  */
 @ApiStatus.Experimental
@@ -87,9 +90,16 @@ public class SentrySQLiteDriver private constructor(private val delegate: SQLite
      *
      * In the case of (2), wrap the open helper passed to the `SupportSQLiteDriver` constructor via
      * `SentrySupportSQLiteOpenHelper` instead.
+     *
+     * Note that wrapping will be performed if the delegate isn't a `SupportSQLiteDriver` itself but
+     * wraps or subclasses one. In that case, ensure the open helper passed to the support driver
+     * constructor is *not* wrapped.
      */
+    // Warning! The SAGP depends on this method's ABI.
     @JvmStatic
     public fun create(delegate: SQLiteDriver): SQLiteDriver =
+      // FQN check simplifies our SAGP implementation, allowing it to naively instrument all
+      // RoomDatabase.Builder.setDriver() call sites.
       if (delegate is SentrySQLiteDriver || delegate.javaClass.name == SUPPORT_SQLITE_DRIVER_FQN) {
         delegate
       } else {

From 6bbdfbea7809761ded2735fc5a81acbab5182dc2 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 25 Jun 2026 12:48:15 +0200
Subject: [PATCH 235/391] chore(changelog): Add 8.43.3 hotfix (#5620)

Add release notes for version 8.43.3 with fixes.
---
 CHANGELOG.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 48a1115f8ae..2049c2b2543 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -64,6 +64,12 @@
 - Fix attachments being duplicated on native events that carry scope attachments ([#5548](https://github.com/getsentry/sentry-java/pull/5548))
 - Fix performance collector scheduling many tasks in a row ([#5524](https://github.com/getsentry/sentry-java/pull/5524))
 
+## 8.43.3
+
+### Fixes
+
+- Fix crash when `getHistoricalProcessStartReasons` is called from an isolated or wrong-userId process ([#5597](https://github.com/getsentry/sentry-java/pull/5597))
+
 ## 8.43.2
 
 ### Improvements

From fa825503d1a24bca46aa0f7a71b9d1a06ee00351 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Thu, 25 Jun 2026 13:42:36 +0200
Subject: [PATCH 236/391] chore(deps): Bump dependencies associated with
 SentrySQLiteDriver (#5630)

Bumps SAGP to 6.13.0, Room 3 to 3.0.0-rc01, and androidx.sqlite to 2.7.0-rc01. Lets us ensure the Android sample app runs against the latest Room build + picks up the SQLiteDriver auto-instrumentation introduced in SAGP 6.13.0.
---
 gradle/libs.versions.toml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 24064703ca1..3984cb7115b 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -33,10 +33,10 @@ otelSemanticConventions = "1.40.0"
 otelSemanticConventionsAlpha = "1.40.0-alpha"
 retrofit = "2.9.0"
 room2 = "2.8.4"
-room3 = "3.0.0-alpha06"
-sagp = "6.10.0"
+room3 = "3.0.0-rc01"
+sagp = "6.13.0"
 sqlite = "2.6.2"
-sqliteAlpha = "2.7.0-alpha06" # Required by Room3 3.0.0-alpha*
+sqliteRc = "2.7.0-rc01" # Required by Room3 3.0.0-rc*
 slf4j = "1.7.30"
 spotless = "8.4.0"
 springboot2 = "2.7.18"
@@ -107,8 +107,8 @@ androidx-room-runtime = { module = "androidx.room:room-runtime", version.ref = "
 androidx-room3-compiler = { module = "androidx.room3:room3-compiler", version.ref = "room3" }
 androidx-room3-runtime = { module = "androidx.room3:room3-runtime", version.ref = "room3" }
 androidx-sqlite = { module = "androidx.sqlite:sqlite", version.ref = "sqlite" }
-androidx-sqlite-bundled = { module = "androidx.sqlite:sqlite-bundled", version.ref = "sqliteAlpha" }
-androidx-sqlite-framework = { module = "androidx.sqlite:sqlite-framework", version.ref = "sqliteAlpha" }
+androidx-sqlite-bundled = { module = "androidx.sqlite:sqlite-bundled", version.ref = "sqliteRc" }
+androidx-sqlite-framework = { module = "androidx.sqlite:sqlite-framework", version.ref = "sqliteRc" }
 androidx-recyclerview = { module = "androidx.recyclerview:recyclerview", version = "1.2.1" }
 androidx-browser = { module = "androidx.browser:browser", version = "1.8.0" }
 async-profiler = { module = "tools.profiler:async-profiler", version.ref = "asyncProfiler" }

From f082155e971b6ff724767cdc68f269f188f58d0a Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 25 Jun 2026 13:46:19 +0200
Subject: [PATCH 237/391] build: Remove redundant Java compatibility block from
 sentry-apollo-4 (#5633)

The root build script already sets sourceCompatibility/targetCompatibility to
VERSION_1_8 for every java-library subproject, so the module-level declaration
was a no-op.
---
 sentry-apollo-4/build.gradle.kts | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/sentry-apollo-4/build.gradle.kts b/sentry-apollo-4/build.gradle.kts
index d9f41891dc1..abb7ccb760e 100644
--- a/sentry-apollo-4/build.gradle.kts
+++ b/sentry-apollo-4/build.gradle.kts
@@ -11,11 +11,6 @@ plugins {
   alias(libs.plugins.animalsniffer)
 }
 
-configure<JavaPluginExtension> {
-  sourceCompatibility = JavaVersion.VERSION_1_8
-  targetCompatibility = JavaVersion.VERSION_1_8
-}
-
 tasks.withType<KotlinCompile>().configureEach {
   compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
   compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9

From e0a2a6e63c9cf289a0d15f16b91b2ce19adf2fc6 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 25 Jun 2026 14:18:18 +0200
Subject: [PATCH 238/391] build: Remove redundant mavenCentral repository
 declarations (#5638)

settings.gradle.kts already declares google(), mavenCentral() and mavenLocal()
via dependencyResolutionManagement for every project, so the module-level
repositories { mavenCentral() } blocks were redundant. With the default
PREFER_PROJECT mode they only narrowed each project to mavenCentral; removing
them falls back to the central superset and resolution is unaffected.
---
 sentry-reactor/build.gradle.kts                                 | 2 --
 .../build.gradle.kts                                            | 2 --
 sentry-samples/sentry-samples-console-otlp/build.gradle.kts     | 2 --
 sentry-samples/sentry-samples-console/build.gradle.kts          | 2 --
 sentry-samples/sentry-samples-jul/build.gradle.kts              | 2 --
 sentry-samples/sentry-samples-log4j2/build.gradle.kts           | 2 --
 sentry-samples/sentry-samples-logback/build.gradle.kts          | 2 --
 sentry-samples/sentry-samples-netflix-dgs/build.gradle.kts      | 2 --
 sentry-samples/sentry-samples-servlet/build.gradle.kts          | 2 --
 sentry-samples/sentry-samples-spring-7/build.gradle.kts         | 2 --
 .../build.gradle.kts                                            | 2 --
 .../sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts | 2 --
 .../sentry-samples-spring-boot-4-otlp/build.gradle.kts          | 2 --
 .../sentry-samples-spring-boot-4-webflux/build.gradle.kts       | 2 --
 sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts    | 2 --
 .../build.gradle.kts                                            | 2 --
 .../build.gradle.kts                                            | 2 --
 .../sentry-samples-spring-boot-jakarta/build.gradle.kts         | 2 --
 .../build.gradle.kts                                            | 2 --
 .../sentry-samples-spring-boot-opentelemetry/build.gradle.kts   | 2 --
 .../sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts | 2 --
 .../sentry-samples-spring-boot-webflux/build.gradle.kts         | 2 --
 sentry-samples/sentry-samples-spring-boot/build.gradle.kts      | 2 --
 sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts   | 2 --
 sentry-samples/sentry-samples-spring/build.gradle.kts           | 2 --
 25 files changed, 50 deletions(-)

diff --git a/sentry-reactor/build.gradle.kts b/sentry-reactor/build.gradle.kts
index 07024b3a23b..615ce38ecc5 100644
--- a/sentry-reactor/build.gradle.kts
+++ b/sentry-reactor/build.gradle.kts
@@ -62,8 +62,6 @@ tasks.withType<JavaCompile>().configureEach {
   }
 }
 
-repositories { mavenCentral() }
-
 tasks.jar {
   manifest {
     attributes(
diff --git a/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
index 23df981060f..5b67053449e 100644
--- a/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console-opentelemetry-noagent/build.gradle.kts
@@ -15,8 +15,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-console-otlp/build.gradle.kts b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
index 9bb0678bf65..232a4ff2248 100644
--- a/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console-otlp/build.gradle.kts
@@ -15,8 +15,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-console/build.gradle.kts b/sentry-samples/sentry-samples-console/build.gradle.kts
index 8fdef6ef70e..f490939ed61 100644
--- a/sentry-samples/sentry-samples-console/build.gradle.kts
+++ b/sentry-samples/sentry-samples-console/build.gradle.kts
@@ -15,8 +15,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-jul/build.gradle.kts b/sentry-samples/sentry-samples-jul/build.gradle.kts
index 5381f3ff2f0..25e682a19ba 100644
--- a/sentry-samples/sentry-samples-jul/build.gradle.kts
+++ b/sentry-samples/sentry-samples-jul/build.gradle.kts
@@ -15,8 +15,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-log4j2/build.gradle.kts b/sentry-samples/sentry-samples-log4j2/build.gradle.kts
index 07df6703c85..52c5c8bb035 100644
--- a/sentry-samples/sentry-samples-log4j2/build.gradle.kts
+++ b/sentry-samples/sentry-samples-log4j2/build.gradle.kts
@@ -15,8 +15,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-logback/build.gradle.kts b/sentry-samples/sentry-samples-logback/build.gradle.kts
index bb37638d8c5..d608f0aa549 100644
--- a/sentry-samples/sentry-samples-logback/build.gradle.kts
+++ b/sentry-samples/sentry-samples-logback/build.gradle.kts
@@ -15,8 +15,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-netflix-dgs/build.gradle.kts b/sentry-samples/sentry-samples-netflix-dgs/build.gradle.kts
index 202b8d8f058..90bc1ffc86f 100644
--- a/sentry-samples/sentry-samples-netflix-dgs/build.gradle.kts
+++ b/sentry-samples/sentry-samples-netflix-dgs/build.gradle.kts
@@ -19,8 +19,6 @@ java.sourceCompatibility = JavaVersion.VERSION_1_8
 
 java.targetCompatibility = JavaVersion.VERSION_1_8
 
-repositories { mavenCentral() }
-
 dependencies {
   implementation(platform(libs.springboot2.bom))
   implementation(libs.springboot.starter.web)
diff --git a/sentry-samples/sentry-samples-servlet/build.gradle.kts b/sentry-samples/sentry-samples-servlet/build.gradle.kts
index 9dc9278bcb9..01ecef54154 100644
--- a/sentry-samples/sentry-samples-servlet/build.gradle.kts
+++ b/sentry-samples/sentry-samples-servlet/build.gradle.kts
@@ -8,8 +8,6 @@ java.sourceCompatibility = JavaVersion.VERSION_1_8
 
 java.targetCompatibility = JavaVersion.VERSION_1_8
 
-repositories { mavenCentral() }
-
 dependencies {
   implementation(projects.sentryServlet)
   implementation("javax.servlet:javax.servlet-api:4.0.1")
diff --git a/sentry-samples/sentry-samples-spring-7/build.gradle.kts b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
index 6de7ed62e9f..daeab91f28d 100644
--- a/sentry-samples/sentry-samples-spring-7/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
@@ -26,8 +26,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 dependencyManagement { imports { mavenBom(SpringBootPlugin.BOM_COORDINATES) } }
 
 dependencies {
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
index afdb92e5c5b..090afbd4542 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry-noagent/build.gradle.kts
@@ -17,8 +17,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
index f0e2d468fec..fa73c191a92 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-opentelemetry/build.gradle.kts
@@ -18,8 +18,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
index d7c2c009bc9..22245cae979 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-otlp/build.gradle.kts
@@ -17,8 +17,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
index 20ccf2d662c..b75f70b3574 100644
--- a/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4-webflux/build.gradle.kts
@@ -17,8 +17,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 dependencies {
   implementation(Config.Libs.kotlinReflect)
   implementation(kotlin(Config.kotlinStdLib, KotlinCompilerVersion.VERSION))
diff --git a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
index 2cc1f34b9eb..17ec5b2a45f 100644
--- a/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-4/build.gradle.kts
@@ -17,8 +17,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 configure<JavaPluginExtension> {
   sourceCompatibility = JavaVersion.VERSION_17
   targetCompatibility = JavaVersion.VERSION_17
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
index 553affc3620..39d6dbf39b6 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry-noagent/build.gradle.kts
@@ -18,8 +18,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 dependencyManagement {
   imports {
     mavenBom("org.springframework.boot:spring-boot-dependencies:${libs.versions.springboot3.get()}")
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
index e4fefab7de7..6f1af65dc88 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta-opentelemetry/build.gradle.kts
@@ -19,8 +19,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 dependencyManagement {
   imports {
     mavenBom("org.springframework.boot:spring-boot-dependencies:${libs.versions.springboot3.get()}")
diff --git a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
index 65850a6f2bd..320a9cc2512 100644
--- a/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-jakarta/build.gradle.kts
@@ -18,8 +18,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 dependencyManagement {
   imports {
     mavenBom("org.springframework.boot:spring-boot-dependencies:${libs.versions.springboot3.get()}")
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
index e32eec82ac8..27d0cd1a772 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry-noagent/build.gradle.kts
@@ -21,8 +21,6 @@ java.sourceCompatibility = JavaVersion.VERSION_11
 
 java.targetCompatibility = JavaVersion.VERSION_11
 
-repositories { mavenCentral() }
-
 fun springBoot2SupportsOptionalIntegrations(): Boolean {
   val version = libs.versions.springboot2.get().removeSuffix(".RELEASE")
   val parts = version.split(".").map { it.toIntOrNull() ?: 0 }
diff --git a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
index 085d6e362af..37aae899e4f 100644
--- a/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-opentelemetry/build.gradle.kts
@@ -21,8 +21,6 @@ java.sourceCompatibility = JavaVersion.VERSION_11
 
 java.targetCompatibility = JavaVersion.VERSION_11
 
-repositories { mavenCentral() }
-
 fun springBoot2SupportsOptionalIntegrations(): Boolean {
   val version = libs.versions.springboot2.get().removeSuffix(".RELEASE")
   val parts = version.split(".").map { it.toIntOrNull() ?: 0 }
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
index 3e462517ded..213eb60296d 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-webflux-jakarta/build.gradle.kts
@@ -18,8 +18,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 dependencyManagement {
   imports {
     mavenBom("org.springframework.boot:spring-boot-dependencies:${libs.versions.springboot3.get()}")
diff --git a/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
index 8dc51e07a53..836608500dc 100644
--- a/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot-webflux/build.gradle.kts
@@ -21,8 +21,6 @@ java.sourceCompatibility = JavaVersion.VERSION_11
 
 java.targetCompatibility = JavaVersion.VERSION_11
 
-repositories { mavenCentral() }
-
 fun springBoot2SupportsGraphql(): Boolean {
   val version = libs.versions.springboot2.get().removeSuffix(".RELEASE")
   val parts = version.split(".").map { it.toIntOrNull() ?: 0 }
diff --git a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
index 54fe99d56d4..0c8d2dc28e7 100644
--- a/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-boot/build.gradle.kts
@@ -21,8 +21,6 @@ java.sourceCompatibility = JavaVersion.VERSION_11
 
 java.targetCompatibility = JavaVersion.VERSION_11
 
-repositories { mavenCentral() }
-
 fun springBoot2SupportsOptionalIntegrations(): Boolean {
   val version = libs.versions.springboot2.get().removeSuffix(".RELEASE")
   val parts = version.split(".").map { it.toIntOrNull() ?: 0 }
diff --git a/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts b/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
index 5fe0334a629..2b360019cb5 100644
--- a/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-jakarta/build.gradle.kts
@@ -24,8 +24,6 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-repositories { mavenCentral() }
-
 // Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
 extra["kotlin-coroutines.version"] = "1.9.0"
 
diff --git a/sentry-samples/sentry-samples-spring/build.gradle.kts b/sentry-samples/sentry-samples-spring/build.gradle.kts
index 3ab6610d96d..236e577a17a 100644
--- a/sentry-samples/sentry-samples-spring/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring/build.gradle.kts
@@ -25,8 +25,6 @@ java {
   targetCompatibility = JavaVersion.VERSION_1_8
 }
 
-repositories { mavenCentral() }
-
 // Apollo 4.x requires coroutines 1.9.0+, override Spring Boot's managed version
 extra["kotlin-coroutines.version"] = "1.9.0"
 

From 2ebf90a0da3127c7b3adee4a86fe3c142bc6fa26 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Thu, 25 Jun 2026 15:45:49 +0200
Subject: [PATCH 239/391] perf(core): SDK Overhead Reduction (#5499)

* collection: SDK Overhead Reduction

* perf(core): Skip java.specification.version lookup on Android

Android is never Java 9+, so the System.getProperty +
Double.valueOf parse in the Platform static initializer is
unnecessary overhead on the Android cold-start path.
Short-circuit to isJavaNinePlus=false when isAndroid is true.

* perf(android): Replace reflective OptionsContainer with direct subclass

Replace OptionsContainer.create(SentryAndroidOptions.class) which uses
getDeclaredConstructor().newInstance() with a direct
SentryAndroidOptionsContainer subclass that returns
new SentryAndroidOptions() without reflection.

Make OptionsContainer non-final (@Open) with a protected no-arg
constructor so Android can subclass it.

* collection: SDK Overhead reduction for JVM

* perf(core): Short-circuit combined scope breadcrumbs

Avoid allocating and sorting a merged breadcrumb queue when only one component scope has breadcrumbs. This keeps the full merge path for multi-scope breadcrumbs and returns the default write scope queue when all scopes are empty.

Co-Authored-By: Claude <noreply@anthropic.com>

* perf(core): Reduce envelope writer buffer size

Use an explicit 512-character BufferedWriter buffer for envelope item and envelope serialization. This avoids allocating the oversized default char buffer for each short-lived serialization writer while preserving the existing OutputStreamWriter-based encoding path.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* perf(core): Remove redundant event map copies

Avoid creating temporary maps when applying scope and options tags or scope extras. The event setters already copy these maps, so this preserves snapshot semantics while reducing allocation overhead.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* changelog

* perf(core): Short-circuit combined scope collections

Avoid allocating merged collection copies when only one combined scope contains values. This extends the breadcrumbs optimization to tags, attributes, extras, and attachments while preserving merge behavior when multiple scopes contribute data.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* perf(android): Use TimeZone.getDefault for device timezone

Avoid constructing a Calendar only to read the default device timezone. The locale passed to Calendar does not affect the timezone value, so TimeZone.getDefault returns the same value with less work during device context collection.

Co-Authored-By: Claude <noreply@anthropic.com>

* perf(core): Replace Calendar with Date in DateUtils

Avoid constructing Calendar instances when DateUtils only needs the current epoch millis or a Date for an existing millis value. Date stores epoch millis without timezone state, so the returned values are unchanged while avoiding unnecessary Calendar allocation and field computation.

Co-Authored-By: Claude <noreply@anthropic.com>

* perf(core): Reduce JsonWriter stack allocation

Shrink the vendored JsonWriter nesting stack from 32 entries to 8 entries. The stack still grows on demand for deeply nested payloads, while common SDK serialization avoids the larger initial array allocation.

Co-Authored-By: Claude <noreply@anthropic.com>

* perf(core): Lazily allocate Breadcrumb data

Avoid allocating a ConcurrentHashMap for breadcrumbs that never set data. Initialize the data map on first write while preserving concurrent writes with double-checked locking.

Co-Authored-By: Claude <noreply@anthropic.com>

* perf(core): Reduce context serialization allocations

Use sorted key arrays when serializing contexts to avoid allocating an ArrayList for each serialization. This preserves deterministic key ordering while keeping the snapshot representation smaller.

Co-Authored-By: Claude <noreply@anthropic.com>

* perf(core): Lazily allocate reflection serializer state

Defer creation of the reflection serializer visiting set until reflection serialization is actually needed. Normal SDK payload serialization uses explicit serializers, so this avoids an unused HashSet allocation for each writer.

* perf(core): Lazily create reflection JSON serializer

Defer creation of JsonReflectionObjectSerializer until unknown-object reflection serialization is needed. Normal SDK payloads use explicit serializers, so this avoids allocating unused reflection serializer state for each writer.

* fix(android): Preserve locale timezone extension

Keep the Calendar-based timezone path for Android 13+ locales that carry a Unicode tz extension. This preserves the existing device timezone behavior while keeping the direct default timezone fast path for normal locales.

Co-Authored-By: Claude <noreply@anthropic.com>

* perf(core): Replace ISO8601 timestamp handling

Replace the Calendar-backed vendored ISO8601 formatting and parsing path with a small Sentry-specific utility that works directly from epoch milliseconds.

This avoids formatter and parser allocations on timestamp-heavy serialization paths while keeping the existing DateUtils API as the facade.

Co-Authored-By: Claude <noreply@anthropic.com>

* ref(core): Move ISO8601 utility to vendor package

Move the Sentry ISO8601 helper under the vendor package and mark it as internal API so the adapted public-domain date conversion code is isolated from core SDK classes.

Update attribution metadata to reflect the public-domain dedication source.

Co-Authored-By: Claude <noreply@anthropic.com>

* perf(core): Avoid cloning Date getters

* fix(core): Preserve ISO8601 utility compatibility

Match edge-case behavior from the previous vendored ISO8601 utility for date-only timestamps, trailing characters after Z, and Gregorian cutover dates.

* fix(core): Preserve mutable breadcrumb data access

Initialize the lazy breadcrumb data map when callers request the full map. This keeps getData() mutable for existing callers while preserving lazy allocation for breadcrumbs that only serialize or read individual values.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs(android): Explain timezone Calendar fallback

Document why Android 13+ locales with Unicode timezone extensions keep using Calendar while normal locales use the default timezone directly for performance.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(core): Avoid KeySetView in context serialization

Use ConcurrentHashMap.keys() when creating sorted context key snapshots so the serialization path stays compatible with Android API 21. Keep the array snapshot optimization without relying on KeySetView, which AnimalSniffer rejects for the SDK's minSdk.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(core): Add breadcrumb timestamp serialization coverage

Cover that breadcrumbs backed by timestamp milliseconds serialize the same timestamp as breadcrumbs backed by Date for the same instant.

* fix(core): Parse date-only timestamps with timezones

Preserve ISO8601 parser compatibility for date-only values that include a timezone suffix. Keep modern date-only timezone parsing on the fast path and add parity coverage against the previous parser.

* docs(core): Add timezone changelog entry

* docs(core): Add DateUtils changelog entry

* docs(core): Add JsonWriter changelog entry

* docs(core): Add breadcrumb changelog entry

* docs(core): Add contexts changelog entry

* docs(core): Add reflection state changelog entry

* docs(core): Add reflection serializer changelog entry

* docs(core): Add ISO8601 handling changelog entry

* docs(core): Add Date getter changelog entries

* changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  26 ++
 THIRD_PARTY_NOTICES.md                        |  16 +
 .../sentry/android/core/DeviceInfoUtil.java   |  11 +-
 .../io/sentry/android/core/SentryAndroid.java |   3 +-
 .../core/SentryAndroidOptionsContainer.java   |  16 +
 .../sentry/android/core/DeviceInfoUtilTest.kt |  32 ++
 sentry/api/sentry.api                         |  10 +-
 .../src/main/java/io/sentry/Breadcrumb.java   |  65 ++-
 .../java/io/sentry/CombinedScopeView.java     | 157 ++++++-
 sentry/src/main/java/io/sentry/DateUtils.java |  35 +-
 .../java/io/sentry/JsonObjectSerializer.java  |  14 +-
 .../JsonReflectionObjectSerializer.java       |  10 +-
 .../main/java/io/sentry/JsonSerializer.java   |   5 +-
 .../java/io/sentry/MainEventProcessor.java    |   3 +-
 .../main/java/io/sentry/MonitorContexts.java  |   6 +-
 .../main/java/io/sentry/OptionsContainer.java |  18 +-
 .../src/main/java/io/sentry/SentryClient.java |   9 +-
 .../java/io/sentry/SentryEnvelopeItem.java    |  41 +-
 .../src/main/java/io/sentry/SentryEvent.java  |   2 +-
 sentry/src/main/java/io/sentry/Session.java   |   8 +-
 .../src/main/java/io/sentry/protocol/App.java |   3 +-
 .../java/io/sentry/protocol/Contexts.java     |   6 +-
 .../main/java/io/sentry/protocol/Device.java  |   3 +-
 .../java/io/sentry/util/CollectionUtils.java  |  21 +
 .../main/java/io/sentry/util/Platform.java    |  21 +-
 .../io/sentry/vendor/SentryIso8601Utils.java  | 397 ++++++++++++++++++
 .../sentry/vendor/gson/stream/JsonWriter.java |   4 +-
 .../src/test/java/io/sentry/BreadcrumbTest.kt |  36 ++
 .../java/io/sentry/CombinedScopeViewTest.kt   |  69 +++
 .../src/test/java/io/sentry/DateUtilsTest.kt  | 204 +++++++++
 .../io/sentry/JsonObjectSerializerTest.kt     |  24 ++
 .../java/io/sentry/MainEventProcessorTest.kt  |  13 +
 .../java/io/sentry/MonitorContextsTest.kt     |  19 +
 .../test/java/io/sentry/SentryClientTest.kt   |  18 +
 .../test/java/io/sentry/protocol/AppTest.kt   |   5 +-
 .../protocol/BreadcrumbSerializationTest.kt   |   8 +
 .../java/io/sentry/protocol/DeviceTest.kt     |   5 +-
 .../SentryBaseEventSerializationTest.kt       |  23 +
 38 files changed, 1252 insertions(+), 114 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptionsContainer.java
 create mode 100644 sentry/src/main/java/io/sentry/vendor/SentryIso8601Utils.java
 create mode 100644 sentry/src/test/java/io/sentry/MonitorContextsTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2049c2b2543..851fc3985e5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,31 @@
 # Changelog
 
+## Unreleased
+
+### Behavioral Changes
+
+- Collections returned by scope (e.g. `getBreadcrumbs`, `getTags`, `getAttachments`) are shared state and should not be mutated. ([#5541](https://github.com/getsentry/sentry-java/pull/5541))
+  - Previously, when going through `CombinedScopeView`, we were returning a copy where mutations didn't show up in the underlying scopes.
+  - This has now changed in order to reduce SDK overhead.
+- `Date` objects returned by SDK data model getters are shared state and should not be mutated. ([#5603](https://github.com/getsentry/sentry-java/pull/5603))
+  - Previously, these getters returned defensive copies for some date fields.
+  - This has now changed in order to reduce SDK overhead.
+
+### Performance
+
+- Reduce writer buffer size from 8192 to 512 ([#5544](https://github.com/getsentry/sentry-java/pull/5544))
+- Remove redundant event map copies ([#5536](https://github.com/getsentry/sentry-java/pull/5536))
+- Optimize combined scope by adding an early return if only one scope has data ([#5541](https://github.com/getsentry/sentry-java/pull/5541))
+- Reduce model access overhead by avoiding defensive `Date` copies in SDK data model getters. ([#5603](https://github.com/getsentry/sentry-java/pull/5603))
+- Reduce timestamp parsing and formatting overhead with Sentry-specific ISO-8601 handling. ([#5602](https://github.com/getsentry/sentry-java/pull/5602))
+- Reduce JSON serialization overhead by creating the reflection serializer only when unknown-object fallback serialization is needed. ([#5601](https://github.com/getsentry/sentry-java/pull/5601))
+- Reduce JSON serialization overhead by allocating reflection cycle-tracking state only when reflection serialization is used. ([#5600](https://github.com/getsentry/sentry-java/pull/5600))
+- Reduce context serialization overhead by sorting key snapshots with arrays instead of temporary lists. ([#5599](https://github.com/getsentry/sentry-java/pull/5599))
+- Reduce breadcrumb allocation overhead by creating the `Breadcrumb` data map only when data is added. ([#5598](https://github.com/getsentry/sentry-java/pull/5598))
+- Reduce JSON serialization overhead by lowering the initial `JsonWriter` nesting stack size while preserving on-demand growth. ([#5591](https://github.com/getsentry/sentry-java/pull/5591))
+- Reduce timestamp helper overhead by replacing unnecessary `Calendar` usage in `DateUtils` with direct `Date` creation. ([#5589](https://github.com/getsentry/sentry-java/pull/5589))
+- Reduce Android startup overhead by using the default timezone directly on older devices or when no timezone info is available in the locale. ([#5587](https://github.com/getsentry/sentry-java/pull/5587))
+
 ## 8.45.0
 
 ### Features
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index 925add4a71a..7b87b92dcb3 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -62,6 +62,22 @@ limitations under the License.
 
 ---
 
+## Howard Hinnant — Date Algorithms (Public Domain)
+
+**Source:** https://howardhinnant.github.io/date_algorithms.html<br>
+**License:** Public Domain<br>
+**Copyright:** None; public domain dedication by Howard Hinnant
+
+### Scope
+
+The Sentry Java SDK includes adapted civil date conversion algorithms from Howard Hinnant's date algorithms for UTC ISO 8601 timestamp parsing and formatting. The code resides in `io.sentry.vendor.SentryIso8601Utils`.
+
+```
+Consider these donated to the public domain.
+```
+
+---
+
 ## Android Open Source Project — Base64 (Apache 2.0)
 
 **Source:** https://cs.android.com/android/platform/superproject/main/+/main:frameworks/base/core/java/android/util/Base64.java<br>
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/DeviceInfoUtil.java b/sentry-android-core/src/main/java/io/sentry/android/core/DeviceInfoUtil.java
index f3b17c5854a..63b88c0e440 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/DeviceInfoUtil.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/DeviceInfoUtil.java
@@ -257,14 +257,19 @@ private void setDeviceIO(
   @SuppressWarnings("NewApi")
   @NotNull
   private TimeZone getTimeZone() {
-    if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.N) {
+    // Only use the costly Calendar API on Android 13+ (API Level 33+) when the locale contains a
+    // Unicode timezone extension (for example "en-US-u-tz-usnyc"), because Calendar honors that
+    // extension. For all other cases, use the process default timezone directly for performance.
+    if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.TIRAMISU) {
       LocaleList locales = context.getResources().getConfiguration().getLocales();
       if (!locales.isEmpty()) {
         Locale locale = locales.get(0);
-        return Calendar.getInstance(locale).getTimeZone();
+        if (locale.getUnicodeLocaleType("tz") != null) {
+          return Calendar.getInstance(locale).getTimeZone();
+        }
       }
     }
-    return Calendar.getInstance().getTimeZone();
+    return TimeZone.getDefault();
   }
 
   @SuppressWarnings("JdkObsolete")
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroid.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroid.java
index 0d249f73790..f27259fd635 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroid.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroid.java
@@ -9,7 +9,6 @@
 import io.sentry.IScopes;
 import io.sentry.ISentryLifecycleToken;
 import io.sentry.Integration;
-import io.sentry.OptionsContainer;
 import io.sentry.Sentry;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
@@ -98,7 +97,7 @@ public static void init(
       @NotNull Sentry.OptionsConfiguration<SentryAndroidOptions> configuration) {
     try (final @NotNull ISentryLifecycleToken ignored = staticLock.acquire()) {
       Sentry.init(
-          OptionsContainer.create(SentryAndroidOptions.class),
+          new SentryAndroidOptionsContainer(),
           options -> {
             final io.sentry.util.LoadClass classLoader = new io.sentry.util.LoadClass();
             final boolean isTimberUpstreamAvailable =
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptionsContainer.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptionsContainer.java
new file mode 100644
index 00000000000..678f7ab29b2
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptionsContainer.java
@@ -0,0 +1,16 @@
+package io.sentry.android.core;
+
+import io.sentry.OptionsContainer;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Direct OptionsContainer for SentryAndroidOptions that avoids reflective
+ * getDeclaredConstructor().newInstance() on the Android startup path.
+ */
+final class SentryAndroidOptionsContainer extends OptionsContainer<SentryAndroidOptions> {
+
+  @Override
+  public @NotNull SentryAndroidOptions createInstance() {
+    return new SentryAndroidOptions();
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/DeviceInfoUtilTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/DeviceInfoUtilTest.kt
index 6d90d6be538..faf993e1610 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/DeviceInfoUtilTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/DeviceInfoUtilTest.kt
@@ -2,16 +2,22 @@ package io.sentry.android.core
 
 import android.content.Context
 import android.content.Intent
+import android.content.res.Configuration
 import android.os.BatteryManager
+import android.os.Build
+import android.os.LocaleList
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.android.core.internal.util.CpuInfoUtils
+import java.util.Locale
+import java.util.TimeZone
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
 
 @RunWith(AndroidJUnit4::class)
 class DeviceInfoUtilTest {
@@ -47,6 +53,32 @@ class DeviceInfoUtilTest {
     assertNotNull(deviceInfo.memorySize)
   }
 
+  @Test
+  fun `sets default timezone`() {
+    val deviceInfoUtil = DeviceInfoUtil.getInstance(context, SentryAndroidOptions())
+    val deviceInfo = deviceInfoUtil.collectDeviceInformation(false, false)
+
+    assertEquals(TimeZone.getDefault(), deviceInfo.timezone)
+  }
+
+  @Test
+  @Config(sdk = [Build.VERSION_CODES.TIRAMISU])
+  fun `preserves timezone from locale unicode extension`() {
+    val defaultTimeZone = TimeZone.getDefault()
+    try {
+      TimeZone.setDefault(TimeZone.getTimeZone("UTC"))
+      val configuration = Configuration(context.resources.configuration)
+      configuration.setLocales(LocaleList(Locale.forLanguageTag("en-US-u-tz-usnyc")))
+      val localizedContext = context.createConfigurationContext(configuration)
+      val deviceInfoUtil = DeviceInfoUtil(localizedContext, SentryAndroidOptions())
+      val deviceInfo = deviceInfoUtil.collectDeviceInformation(false, false)
+
+      assertEquals("America/New_York", deviceInfo.timezone?.id)
+    } finally {
+      TimeZone.setDefault(defaultTimeZone)
+    }
+  }
+
   @Test
   fun `does include cpu data`() {
     CpuInfoUtils.getInstance().setCpuMaxFrequencies(listOf(1024))
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index e9083350349..04c876fdbdb 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -1312,7 +1312,6 @@ public final class io/sentry/JsonObjectReader : io/sentry/ObjectReader {
 
 public final class io/sentry/JsonObjectSerializer {
 	public static final field OBJECT_PLACEHOLDER Ljava/lang/String;
-	public final field jsonReflectionObjectSerializer Lio/sentry/JsonReflectionObjectSerializer;
 	public fun <init> (I)V
 	public fun serialize (Lio/sentry/ObjectWriter;Lio/sentry/ILogger;Ljava/lang/Object;)V
 }
@@ -2067,7 +2066,8 @@ public abstract interface class io/sentry/ObjectWriter {
 	public abstract fun value (Z)Lio/sentry/ObjectWriter;
 }
 
-public final class io/sentry/OptionsContainer {
+public class io/sentry/OptionsContainer {
+	protected fun <init> ()V
 	public static fun create (Ljava/lang/Class;)Lio/sentry/OptionsContainer;
 	public fun createInstance ()Ljava/lang/Object;
 }
@@ -7618,6 +7618,7 @@ public final class io/sentry/util/CollectionUtils {
 	public static fun newHashMap (Ljava/util/Map;)Ljava/util/Map;
 	public static fun reverseListIterator (Ljava/util/concurrent/CopyOnWriteArrayList;)Ljava/util/ListIterator;
 	public static fun size (Ljava/lang/Iterable;)I
+	public static fun toSortedStringArray (Ljava/util/Enumeration;I)[Ljava/lang/String;
 }
 
 public abstract interface class io/sentry/util/CollectionUtils$Mapper {
@@ -8075,6 +8076,11 @@ public class io/sentry/vendor/Base64 {
 	public static fun encodeToString ([BIII)Ljava/lang/String;
 }
 
+public final class io/sentry/vendor/SentryIso8601Utils {
+	public static fun formatTimestamp (J)Ljava/lang/String;
+	public static fun parseTimestamp (Ljava/lang/String;)J
+}
+
 public class io/sentry/vendor/gson/internal/bind/util/ISO8601Utils {
 	public static final field TIMEZONE_UTC Ljava/util/TimeZone;
 	public fun <init> ()V
diff --git a/sentry/src/main/java/io/sentry/Breadcrumb.java b/sentry/src/main/java/io/sentry/Breadcrumb.java
index d122d1459bf..fff6954ee56 100644
--- a/sentry/src/main/java/io/sentry/Breadcrumb.java
+++ b/sentry/src/main/java/io/sentry/Breadcrumb.java
@@ -34,8 +34,10 @@ public final class Breadcrumb implements JsonUnknown, JsonSerializable, Comparab
   /** The type of breadcrumb. */
   private @Nullable String type;
 
+  private static final @NotNull Map<String, @NotNull Object> EMPTY_DATA = Collections.emptyMap();
+
   /** Data associated with this breadcrumb. */
-  private @NotNull Map<String, @NotNull Object> data = new ConcurrentHashMap<>();
+  private volatile @NotNull Map<String, @NotNull Object> data = EMPTY_DATA;
 
   /** Dotted strings that indicate what the crumb is or where it comes from. */
   private @Nullable String category;
@@ -78,9 +80,11 @@ public Breadcrumb(final long timestamp) {
     this.type = breadcrumb.type;
     this.category = breadcrumb.category;
     this.origin = breadcrumb.origin;
-    final Map<String, Object> dataClone = CollectionUtils.newConcurrentHashMap(breadcrumb.data);
-    if (dataClone != null) {
-      this.data = dataClone;
+    if (!breadcrumb.data.isEmpty()) {
+      final Map<String, Object> dataClone = CollectionUtils.newConcurrentHashMap(breadcrumb.data);
+      if (dataClone != null) {
+        this.data = dataClone;
+      }
     }
     this.unknown = CollectionUtils.newConcurrentHashMap(breadcrumb.unknown);
     this.level = breadcrumb.level;
@@ -100,7 +104,7 @@ public static Breadcrumb fromMap(
     @NotNull Date timestamp = DateUtils.getCurrentDateTime();
     String message = null;
     String type = null;
-    @NotNull Map<String, Object> data = new ConcurrentHashMap<>();
+    Map<String, Object> data = null;
     String category = null;
     String origin = null;
     SentryLevel level = null;
@@ -129,6 +133,9 @@ public static Breadcrumb fromMap(
           if (untypedData != null) {
             for (Map.Entry<Object, Object> dataEntry : untypedData.entrySet()) {
               if (dataEntry.getKey() instanceof String && dataEntry.getValue() != null) {
+                if (data == null) {
+                  data = new ConcurrentHashMap<>();
+                }
                 data.put((String) dataEntry.getKey(), dataEntry.getValue());
               } else {
                 options
@@ -166,7 +173,9 @@ public static Breadcrumb fromMap(
     final Breadcrumb breadcrumb = new Breadcrumb(timestamp);
     breadcrumb.message = message;
     breadcrumb.type = type;
-    breadcrumb.data = data;
+    if (data != null) {
+      breadcrumb.data = data;
+    }
     breadcrumb.category = category;
     breadcrumb.origin = origin;
     breadcrumb.level = level;
@@ -494,7 +503,7 @@ public static Breadcrumb fromMap(
       breadcrumb.setData("view.tag", viewTag);
     }
     for (final Map.Entry<String, Object> entry : additionalData.entrySet()) {
-      breadcrumb.getData().put(entry.getKey(), entry.getValue());
+      breadcrumb.setData(entry.getKey(), entry.getValue());
     }
     breadcrumb.setLevel(SentryLevel.INFO);
     return breadcrumb;
@@ -553,9 +562,9 @@ public Breadcrumb(@Nullable String message) {
   @SuppressWarnings("JavaUtilDate")
   public @NotNull Date getTimestamp() {
     if (timestamp != null) {
-      return (Date) timestamp.clone();
+      return timestamp;
     } else if (timestampMs != null) {
-      // we memoize it here into timestamp to avoid instantiating Calendar again and again
+      // we memoize it here into timestamp to avoid creating a Date again and again
       timestamp = DateUtils.getDateTime(timestampMs);
       return timestamp;
     }
@@ -598,6 +607,20 @@ public void setType(@Nullable String type) {
     this.type = type;
   }
 
+  private @NotNull Map<String, @NotNull Object> getOrCreateData() {
+    Map<String, @NotNull Object> currentData = data;
+    if (currentData == EMPTY_DATA) {
+      synchronized (this) {
+        currentData = data;
+        if (currentData == EMPTY_DATA) {
+          currentData = new ConcurrentHashMap<>();
+          data = currentData;
+        }
+      }
+    }
+    return currentData;
+  }
+
   /**
    * Returns the data map
    *
@@ -606,7 +629,7 @@ public void setType(@Nullable String type) {
   @ApiStatus.Internal
   @NotNull
   public Map<String, Object> getData() {
-    return data;
+    return getOrCreateData();
   }
 
   /**
@@ -636,7 +659,7 @@ public void setData(@Nullable String key, @Nullable Object value) {
     if (value == null) {
       removeData(key);
     } else {
-      data.put(key, value);
+      getOrCreateData().put(key, value);
     }
   }
 
@@ -649,7 +672,10 @@ public void removeData(@Nullable String key) {
     if (key == null) {
       return;
     }
-    data.remove(key);
+    final Map<String, @NotNull Object> currentData = data;
+    if (currentData != EMPTY_DATA) {
+      currentData.remove(key);
+    }
   }
 
   /**
@@ -823,7 +849,12 @@ public static final class JsonKeys {
   public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger logger)
       throws IOException {
     writer.beginObject();
-    writer.name(JsonKeys.TIMESTAMP).value(logger, getTimestamp());
+    writer
+        .name(JsonKeys.TIMESTAMP)
+        .value(
+            timestampMs != null
+                ? DateUtils.getTimestampFromMillis(timestampMs)
+                : DateUtils.getTimestamp(getTimestamp()));
     if (message != null) {
       writer.name(JsonKeys.MESSAGE).value(message);
     }
@@ -859,7 +890,7 @@ public static final class Deserializer implements JsonDeserializer<Breadcrumb> {
       @NotNull Date timestamp = DateUtils.getCurrentDateTime();
       String message = null;
       String type = null;
-      @NotNull Map<String, Object> data = new ConcurrentHashMap<>();
+      Map<String, Object> data = null;
       String category = null;
       String origin = null;
       SentryLevel level = null;
@@ -884,7 +915,7 @@ public static final class Deserializer implements JsonDeserializer<Breadcrumb> {
             Map<String, Object> deserializedData =
                 CollectionUtils.newConcurrentHashMap(
                     (Map<String, Object>) reader.nextObjectOrNull());
-            if (deserializedData != null) {
+            if (deserializedData != null && !deserializedData.isEmpty()) {
               data = deserializedData;
             }
             break;
@@ -913,7 +944,9 @@ public static final class Deserializer implements JsonDeserializer<Breadcrumb> {
       Breadcrumb breadcrumb = new Breadcrumb(timestamp);
       breadcrumb.message = message;
       breadcrumb.type = type;
-      breadcrumb.data = data;
+      if (data != null) {
+        breadcrumb.data = data;
+      }
       breadcrumb.category = category;
       breadcrumb.origin = origin;
       breadcrumb.level = level;
diff --git a/sentry/src/main/java/io/sentry/CombinedScopeView.java b/sentry/src/main/java/io/sentry/CombinedScopeView.java
index f21f8697fa4..ea2d752d44b 100644
--- a/sentry/src/main/java/io/sentry/CombinedScopeView.java
+++ b/sentry/src/main/java/io/sentry/CombinedScopeView.java
@@ -171,10 +171,31 @@ public void setFingerprint(@NotNull List<String> fingerprint) {
 
   @Override
   public @NotNull Queue<Breadcrumb> getBreadcrumbs() {
+    final @NotNull Queue<Breadcrumb> globalBreadcrumbs = globalScope.getBreadcrumbs();
+    final @NotNull Queue<Breadcrumb> isolationBreadcrumbs = isolationScope.getBreadcrumbs();
+    final @NotNull Queue<Breadcrumb> currentBreadcrumbs = scope.getBreadcrumbs();
+
+    final boolean hasGlobalBreadcrumbs = !globalBreadcrumbs.isEmpty();
+    final boolean hasIsolationBreadcrumbs = !isolationBreadcrumbs.isEmpty();
+    final boolean hasCurrentBreadcrumbs = !currentBreadcrumbs.isEmpty();
+
+    if (!hasGlobalBreadcrumbs && !hasIsolationBreadcrumbs && !hasCurrentBreadcrumbs) {
+      return getDefaultScopeValue(globalBreadcrumbs, isolationBreadcrumbs, currentBreadcrumbs);
+    }
+    if (!hasIsolationBreadcrumbs && !hasCurrentBreadcrumbs) {
+      return globalBreadcrumbs;
+    }
+    if (!hasGlobalBreadcrumbs && !hasCurrentBreadcrumbs) {
+      return isolationBreadcrumbs;
+    }
+    if (!hasGlobalBreadcrumbs && !hasIsolationBreadcrumbs) {
+      return currentBreadcrumbs;
+    }
+
     final @NotNull List<Breadcrumb> allBreadcrumbs = new ArrayList<>();
-    allBreadcrumbs.addAll(globalScope.getBreadcrumbs());
-    allBreadcrumbs.addAll(isolationScope.getBreadcrumbs());
-    allBreadcrumbs.addAll(scope.getBreadcrumbs());
+    allBreadcrumbs.addAll(globalBreadcrumbs);
+    allBreadcrumbs.addAll(isolationBreadcrumbs);
+    allBreadcrumbs.addAll(currentBreadcrumbs);
     Collections.sort(allBreadcrumbs);
 
     final @NotNull Queue<Breadcrumb> breadcrumbs =
@@ -224,10 +245,31 @@ public void clear() {
 
   @Override
   public @NotNull Map<String, String> getTags() {
+    final @NotNull Map<String, String> globalTags = globalScope.getTags();
+    final @NotNull Map<String, String> isolationTags = isolationScope.getTags();
+    final @NotNull Map<String, String> currentTags = scope.getTags();
+
+    final boolean hasGlobalTags = !globalTags.isEmpty();
+    final boolean hasIsolationTags = !isolationTags.isEmpty();
+    final boolean hasCurrentTags = !currentTags.isEmpty();
+
+    if (!hasGlobalTags && !hasIsolationTags && !hasCurrentTags) {
+      return getDefaultScopeValue(globalTags, isolationTags, currentTags);
+    }
+    if (!hasIsolationTags && !hasCurrentTags) {
+      return globalTags;
+    }
+    if (!hasGlobalTags && !hasCurrentTags) {
+      return isolationTags;
+    }
+    if (!hasGlobalTags && !hasIsolationTags) {
+      return currentTags;
+    }
+
     final @NotNull Map<String, String> allTags = new ConcurrentHashMap<>();
-    allTags.putAll(globalScope.getTags());
-    allTags.putAll(isolationScope.getTags());
-    allTags.putAll(scope.getTags());
+    allTags.putAll(globalTags);
+    allTags.putAll(isolationTags);
+    allTags.putAll(currentTags);
     return allTags;
   }
 
@@ -243,10 +285,32 @@ public void removeTag(@Nullable String key) {
 
   @Override
   public @NotNull Map<String, SentryAttribute> getAttributes() {
+    final @NotNull Map<String, SentryAttribute> globalAttributes = globalScope.getAttributes();
+    final @NotNull Map<String, SentryAttribute> isolationAttributes =
+        isolationScope.getAttributes();
+    final @NotNull Map<String, SentryAttribute> currentAttributes = scope.getAttributes();
+
+    final boolean hasGlobalAttributes = !globalAttributes.isEmpty();
+    final boolean hasIsolationAttributes = !isolationAttributes.isEmpty();
+    final boolean hasCurrentAttributes = !currentAttributes.isEmpty();
+
+    if (!hasGlobalAttributes && !hasIsolationAttributes && !hasCurrentAttributes) {
+      return getDefaultScopeValue(globalAttributes, isolationAttributes, currentAttributes);
+    }
+    if (!hasIsolationAttributes && !hasCurrentAttributes) {
+      return globalAttributes;
+    }
+    if (!hasGlobalAttributes && !hasCurrentAttributes) {
+      return isolationAttributes;
+    }
+    if (!hasGlobalAttributes && !hasIsolationAttributes) {
+      return currentAttributes;
+    }
+
     final @NotNull Map<String, SentryAttribute> allAttributes = new ConcurrentHashMap<>();
-    allAttributes.putAll(globalScope.getAttributes());
-    allAttributes.putAll(isolationScope.getAttributes());
-    allAttributes.putAll(scope.getAttributes());
+    allAttributes.putAll(globalAttributes);
+    allAttributes.putAll(isolationAttributes);
+    allAttributes.putAll(currentAttributes);
     return allAttributes;
   }
 
@@ -272,11 +336,32 @@ public void removeAttribute(@Nullable String key) {
 
   @Override
   public @NotNull Map<String, Object> getExtras() {
-    final @NotNull Map<String, Object> allTags = new ConcurrentHashMap<>();
-    allTags.putAll(globalScope.getExtras());
-    allTags.putAll(isolationScope.getExtras());
-    allTags.putAll(scope.getExtras());
-    return allTags;
+    final @NotNull Map<String, Object> globalExtras = globalScope.getExtras();
+    final @NotNull Map<String, Object> isolationExtras = isolationScope.getExtras();
+    final @NotNull Map<String, Object> currentExtras = scope.getExtras();
+
+    final boolean hasGlobalExtras = !globalExtras.isEmpty();
+    final boolean hasIsolationExtras = !isolationExtras.isEmpty();
+    final boolean hasCurrentExtras = !currentExtras.isEmpty();
+
+    if (!hasGlobalExtras && !hasIsolationExtras && !hasCurrentExtras) {
+      return getDefaultScopeValue(globalExtras, isolationExtras, currentExtras);
+    }
+    if (!hasIsolationExtras && !hasCurrentExtras) {
+      return globalExtras;
+    }
+    if (!hasGlobalExtras && !hasCurrentExtras) {
+      return isolationExtras;
+    }
+    if (!hasGlobalExtras && !hasIsolationExtras) {
+      return currentExtras;
+    }
+
+    final @NotNull Map<String, Object> allExtras = new ConcurrentHashMap<>();
+    allExtras.putAll(globalExtras);
+    allExtras.putAll(isolationExtras);
+    allExtras.putAll(currentExtras);
+    return allExtras;
   }
 
   @Override
@@ -342,6 +427,23 @@ public void removeContexts(@Nullable String key) {
     return getSpecificScope(null);
   }
 
+  private <T> @NotNull T getDefaultScopeValue(
+      final @NotNull T globalValue,
+      final @NotNull T isolationValue,
+      final @NotNull T currentValue) {
+    switch (getOptions().getDefaultScopeType()) {
+      case CURRENT:
+        return currentValue;
+      case ISOLATION:
+        return isolationValue;
+      case GLOBAL:
+        return globalValue;
+      default:
+        // calm the compiler
+        return currentValue;
+    }
+  }
+
   IScope getSpecificScope(final @Nullable ScopeType scopeType) {
     if (scopeType != null) {
       switch (scopeType) {
@@ -373,10 +475,31 @@ IScope getSpecificScope(final @Nullable ScopeType scopeType) {
 
   @Override
   public @NotNull List<Attachment> getAttachments() {
+    final @NotNull List<Attachment> globalAttachments = globalScope.getAttachments();
+    final @NotNull List<Attachment> isolationAttachments = isolationScope.getAttachments();
+    final @NotNull List<Attachment> currentAttachments = scope.getAttachments();
+
+    final boolean hasGlobalAttachments = !globalAttachments.isEmpty();
+    final boolean hasIsolationAttachments = !isolationAttachments.isEmpty();
+    final boolean hasCurrentAttachments = !currentAttachments.isEmpty();
+
+    if (!hasGlobalAttachments && !hasIsolationAttachments && !hasCurrentAttachments) {
+      return getDefaultScopeValue(globalAttachments, isolationAttachments, currentAttachments);
+    }
+    if (!hasIsolationAttachments && !hasCurrentAttachments) {
+      return globalAttachments;
+    }
+    if (!hasGlobalAttachments && !hasCurrentAttachments) {
+      return isolationAttachments;
+    }
+    if (!hasGlobalAttachments && !hasIsolationAttachments) {
+      return currentAttachments;
+    }
+
     final @NotNull List<Attachment> allAttachments = new CopyOnWriteArrayList<>();
-    allAttachments.addAll(globalScope.getAttachments());
-    allAttachments.addAll(isolationScope.getAttachments());
-    allAttachments.addAll(scope.getAttachments());
+    allAttachments.addAll(globalAttachments);
+    allAttachments.addAll(isolationAttachments);
+    allAttachments.addAll(currentAttachments);
     return allAttachments;
   }
 
diff --git a/sentry/src/main/java/io/sentry/DateUtils.java b/sentry/src/main/java/io/sentry/DateUtils.java
index e407391c394..fcba83fbe05 100644
--- a/sentry/src/main/java/io/sentry/DateUtils.java
+++ b/sentry/src/main/java/io/sentry/DateUtils.java
@@ -1,13 +1,8 @@
 package io.sentry;
 
-import static io.sentry.vendor.gson.internal.bind.util.ISO8601Utils.TIMEZONE_UTC;
-
-import io.sentry.vendor.gson.internal.bind.util.ISO8601Utils;
+import io.sentry.vendor.SentryIso8601Utils;
 import java.math.BigDecimal;
 import java.math.RoundingMode;
-import java.text.ParseException;
-import java.text.ParsePosition;
-import java.util.Calendar;
 import java.util.Date;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
@@ -15,6 +10,7 @@
 
 /** Utilities to deal with dates */
 @ApiStatus.Internal
+@SuppressWarnings("JavaUtilDate")
 public final class DateUtils {
 
   private DateUtils() {}
@@ -24,10 +20,9 @@ private DateUtils() {}
    *
    * @return the UTC Date
    */
-  @SuppressWarnings("JdkObsolete")
+  @SuppressWarnings("JavaUtilDate")
   public static @NotNull Date getCurrentDateTime() {
-    final Calendar calendar = Calendar.getInstance(TIMEZONE_UTC);
-    return calendar.getTime();
+    return new Date();
   }
 
   /**
@@ -39,8 +34,8 @@ private DateUtils() {}
   public static @NotNull Date getDateTime(final @NotNull String timestamp)
       throws IllegalArgumentException {
     try {
-      return ISO8601Utils.parse(timestamp, new ParsePosition(0));
-    } catch (ParseException e) {
+      return getDateTime(SentryIso8601Utils.parseTimestamp(timestamp));
+    } catch (IllegalArgumentException e) {
       throw new IllegalArgumentException("timestamp is not ISO format " + timestamp);
     }
   }
@@ -51,7 +46,6 @@ private DateUtils() {}
    * @param timestamp millis eg 1581410911.988 (1581410911 seconds and 988 millis)
    * @return the UTC Date
    */
-  @SuppressWarnings("JdkObsolete")
   public static @NotNull Date getDateTimeWithMillisPrecision(final @NotNull String timestamp)
       throws IllegalArgumentException {
     try {
@@ -69,7 +63,17 @@ private DateUtils() {}
    * @return the UTC/ISO 8601 timestamp
    */
   public static @NotNull String getTimestamp(final @NotNull Date date) {
-    return ISO8601Utils.format(date, true);
+    return getTimestampFromMillis(date.getTime());
+  }
+
+  /**
+   * Get the UTC/ISO 8601 timestamp from millis.
+   *
+   * @param millis the UTC millis from the epoch
+   * @return the UTC/ISO 8601 timestamp
+   */
+  static @NotNull String getTimestampFromMillis(final long millis) {
+    return SentryIso8601Utils.formatTimestamp(millis);
   }
 
   /**
@@ -78,10 +82,9 @@ private DateUtils() {}
    * @param millis the UTC millis from the epoch
    * @return the UTC Date
    */
+  @SuppressWarnings("JavaUtilDate")
   public static @NotNull Date getDateTime(final long millis) {
-    final Calendar calendar = Calendar.getInstance(TIMEZONE_UTC);
-    calendar.setTimeInMillis(millis);
-    return calendar.getTime();
+    return new Date(millis);
   }
 
   /**
diff --git a/sentry/src/main/java/io/sentry/JsonObjectSerializer.java b/sentry/src/main/java/io/sentry/JsonObjectSerializer.java
index 5f986746be9..38abc960521 100644
--- a/sentry/src/main/java/io/sentry/JsonObjectSerializer.java
+++ b/sentry/src/main/java/io/sentry/JsonObjectSerializer.java
@@ -28,10 +28,11 @@ public final class JsonObjectSerializer {
 
   public static final String OBJECT_PLACEHOLDER = "[OBJECT]";
 
-  public final JsonReflectionObjectSerializer jsonReflectionObjectSerializer;
+  private final int maxDepth;
+  private @Nullable JsonReflectionObjectSerializer jsonReflectionObjectSerializer;
 
   public JsonObjectSerializer(int maxDepth) {
-    jsonReflectionObjectSerializer = new JsonReflectionObjectSerializer(maxDepth);
+    this.maxDepth = maxDepth;
   }
 
   public void serialize(
@@ -127,7 +128,7 @@ public void serialize(
       writer.value(object.toString());
     } else {
       try {
-        Object serializableObject = jsonReflectionObjectSerializer.serialize(object, logger);
+        Object serializableObject = getJsonReflectionObjectSerializer().serialize(object, logger);
         serialize(writer, logger, serializableObject);
       } catch (Exception exception) {
         logger.log(SentryLevel.ERROR, "Failed serializing unknown object.", exception);
@@ -138,6 +139,13 @@ public void serialize(
 
   // Helper
 
+  private @NotNull JsonReflectionObjectSerializer getJsonReflectionObjectSerializer() {
+    if (jsonReflectionObjectSerializer == null) {
+      jsonReflectionObjectSerializer = new JsonReflectionObjectSerializer(maxDepth);
+    }
+    return jsonReflectionObjectSerializer;
+  }
+
   private void serializeDate(
       @NotNull ObjectWriter writer, @NotNull ILogger logger, @NotNull Date date)
       throws IOException {
diff --git a/sentry/src/main/java/io/sentry/JsonReflectionObjectSerializer.java b/sentry/src/main/java/io/sentry/JsonReflectionObjectSerializer.java
index 97c23031044..bb9ee1fcd3f 100644
--- a/sentry/src/main/java/io/sentry/JsonReflectionObjectSerializer.java
+++ b/sentry/src/main/java/io/sentry/JsonReflectionObjectSerializer.java
@@ -30,7 +30,7 @@
 @ApiStatus.Internal
 public final class JsonReflectionObjectSerializer {
 
-  private final Set<Object> visiting = new HashSet<>();
+  private @Nullable Set<Object> visiting;
   private final int maxDepth;
 
   JsonReflectionObjectSerializer(int maxDepth) {
@@ -69,6 +69,7 @@ public final class JsonReflectionObjectSerializer {
     } else if (object.getClass().isEnum()) {
       return object.toString();
     } else {
+      final Set<Object> visiting = getVisiting();
       if (visiting.contains(object)) {
         logger.log(SentryLevel.INFO, "Cyclic reference detected. Calling toString() on object.");
         return object.toString();
@@ -135,6 +136,13 @@ public final class JsonReflectionObjectSerializer {
 
   // Helper
 
+  private @NotNull Set<Object> getVisiting() {
+    if (visiting == null) {
+      visiting = new HashSet<>();
+    }
+    return visiting;
+  }
+
   private @NotNull List<Object> list(@NotNull Object[] objectArray, @NotNull ILogger logger)
       throws Exception {
     List<Object> list = new ArrayList<>();
diff --git a/sentry/src/main/java/io/sentry/JsonSerializer.java b/sentry/src/main/java/io/sentry/JsonSerializer.java
index 2b24090d0cc..79a1c72bef3 100644
--- a/sentry/src/main/java/io/sentry/JsonSerializer.java
+++ b/sentry/src/main/java/io/sentry/JsonSerializer.java
@@ -64,6 +64,8 @@ public final class JsonSerializer implements ISerializer {
   @SuppressWarnings("CharsetObjectCanBeUsed")
   private static final Charset UTF_8 = Charset.forName("UTF-8");
 
+  private static final int WRITER_BUFFER_SIZE = 512;
+
   /** the SentryOptions */
   private final @NotNull SentryOptions options;
 
@@ -233,7 +235,8 @@ public void serialize(@NotNull SentryEnvelope envelope, @NotNull OutputStream ou
 
     // we do not want to close these as we would also close the stream that was passed in
     final BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
-    final Writer writer = new BufferedWriter(new OutputStreamWriter(bufferedOutputStream, UTF_8));
+    final Writer writer =
+        new BufferedWriter(new OutputStreamWriter(bufferedOutputStream, UTF_8), WRITER_BUFFER_SIZE);
 
     try {
       envelope
diff --git a/sentry/src/main/java/io/sentry/MainEventProcessor.java b/sentry/src/main/java/io/sentry/MainEventProcessor.java
index 8c684bfb65a..d84c9e47be8 100644
--- a/sentry/src/main/java/io/sentry/MainEventProcessor.java
+++ b/sentry/src/main/java/io/sentry/MainEventProcessor.java
@@ -11,7 +11,6 @@
 import java.io.Closeable;
 import java.io.IOException;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.jetbrains.annotations.ApiStatus;
@@ -191,7 +190,7 @@ private void setSdk(final @NotNull SentryBaseEvent event) {
 
   private void setTags(final @NotNull SentryBaseEvent event) {
     if (event.getTags() == null) {
-      event.setTags(new HashMap<>(options.getTags()));
+      event.setTags(options.getTags());
     } else {
       for (Map.Entry<String, String> item : options.getTags().entrySet()) {
         if (!event.getTags().containsKey(item.getKey())) {
diff --git a/sentry/src/main/java/io/sentry/MonitorContexts.java b/sentry/src/main/java/io/sentry/MonitorContexts.java
index 193d9ee5a6f..a52ecc6b97f 100644
--- a/sentry/src/main/java/io/sentry/MonitorContexts.java
+++ b/sentry/src/main/java/io/sentry/MonitorContexts.java
@@ -1,10 +1,9 @@
 package io.sentry;
 
+import io.sentry.util.CollectionUtils;
 import io.sentry.util.Objects;
 import io.sentry.vendor.gson.stream.JsonToken;
 import java.io.IOException;
-import java.util.Collections;
-import java.util.List;
 import java.util.concurrent.ConcurrentHashMap;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -49,8 +48,7 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
       throws IOException {
     writer.beginObject();
     // Serialize in alphabetical order to keep determinism.
-    final List<String> sortedKeys = Collections.list(keys());
-    Collections.sort(sortedKeys);
+    final String[] sortedKeys = CollectionUtils.toSortedStringArray(keys(), size());
     for (final String key : sortedKeys) {
       final Object value = get(key);
       if (value != null) {
diff --git a/sentry/src/main/java/io/sentry/OptionsContainer.java b/sentry/src/main/java/io/sentry/OptionsContainer.java
index 52032880aaf..b29aef2e000 100644
--- a/sentry/src/main/java/io/sentry/OptionsContainer.java
+++ b/sentry/src/main/java/io/sentry/OptionsContainer.java
@@ -1,28 +1,40 @@
 package io.sentry;
 
+import com.jakewharton.nopen.annotation.Open;
+import io.sentry.util.Objects;
 import java.lang.reflect.InvocationTargetException;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 @ApiStatus.Internal
-public final class OptionsContainer<T> {
+@Open
+public class OptionsContainer<T> {
 
   public @NotNull static <T> OptionsContainer<T> create(final @NotNull Class<T> clazz) {
     return new OptionsContainer<>(clazz);
   }
 
-  private final @NotNull Class<T> clazz;
+  private final @Nullable Class<T> clazz;
 
   private OptionsContainer(final @NotNull Class<T> clazz) {
     super();
     this.clazz = clazz;
   }
 
+  /** Constructor for subclasses that create the instance directly without reflection. */
+  protected OptionsContainer() {
+    super();
+    this.clazz = null;
+  }
+
   public @NotNull T createInstance()
       throws InstantiationException,
           IllegalAccessException,
           NoSuchMethodException,
           InvocationTargetException {
-    return clazz.getDeclaredConstructor().newInstance();
+    return Objects.requireNonNull(clazz, "OptionsContainer clazz is required")
+        .getDeclaredConstructor()
+        .newInstance();
   }
 }
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index 78225f05d19..a739eddd9d9 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -27,7 +27,6 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import org.jetbrains.annotations.ApiStatus;
@@ -1425,7 +1424,7 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
       event.setUser(scope.getUser());
     }
     if (event.getTags() == null) {
-      event.setTags(new HashMap<>(scope.getTags()));
+      event.setTags(scope.getTags());
     } else {
       for (Map.Entry<String, String> item : scope.getTags().entrySet()) {
         if (!event.getTags().containsKey(item.getKey())) {
@@ -1483,7 +1482,7 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
         replayEvent.setUser(scope.getUser());
       }
       if (replayEvent.getTags() == null) {
-        replayEvent.setTags(new HashMap<>(scope.getTags()));
+        replayEvent.setTags(scope.getTags());
       } else {
         for (Map.Entry<String, String> item : scope.getTags().entrySet()) {
           if (!replayEvent.getTags().containsKey(item.getKey())) {
@@ -1523,7 +1522,7 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
         sentryBaseEvent.setUser(scope.getUser());
       }
       if (sentryBaseEvent.getTags() == null) {
-        sentryBaseEvent.setTags(new HashMap<>(scope.getTags()));
+        sentryBaseEvent.setTags(scope.getTags());
       } else {
         for (Map.Entry<String, String> item : scope.getTags().entrySet()) {
           if (!sentryBaseEvent.getTags().containsKey(item.getKey())) {
@@ -1537,7 +1536,7 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
         sortBreadcrumbsByDate(sentryBaseEvent, scope.getBreadcrumbs());
       }
       if (sentryBaseEvent.getExtras() == null) {
-        sentryBaseEvent.setExtras(new HashMap<>(scope.getExtras()));
+        sentryBaseEvent.setExtras(scope.getExtras());
       } else {
         for (Map.Entry<String, Object> item : scope.getExtras().entrySet()) {
           if (!sentryBaseEvent.getExtras().containsKey(item.getKey())) {
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
index dbbc36524db..728478f5906 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
@@ -41,6 +41,8 @@ public final class SentryEnvelopeItem {
   @SuppressWarnings("CharsetObjectCanBeUsed")
   private static final Charset UTF_8 = Charset.forName("UTF-8");
 
+  private static final int WRITER_BUFFER_SIZE = 512;
+
   private final SentryEnvelopeItemHeader header;
   // Either dataFactory is set or data needs to be set.
   private final @Nullable Callable<byte[]> dataFactory;
@@ -85,7 +87,9 @@ public final class SentryEnvelopeItem {
         new CachedItem(
             () -> {
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                  final Writer writer =
+                      new BufferedWriter(
+                          new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                 serializer.serialize(session, writer);
                 return stream.toByteArray();
               }
@@ -119,7 +123,9 @@ public final class SentryEnvelopeItem {
         new CachedItem(
             () -> {
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                  final Writer writer =
+                      new BufferedWriter(
+                          new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                 serializer.serialize(event, writer);
                 return stream.toByteArray();
               }
@@ -179,7 +185,9 @@ public static SentryEnvelopeItem fromUserFeedback(
         new CachedItem(
             () -> {
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                  final Writer writer =
+                      new BufferedWriter(
+                          new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                 serializer.serialize(userFeedback, writer);
                 return stream.toByteArray();
               }
@@ -206,7 +214,9 @@ public static SentryEnvelopeItem fromCheckIn(
         new CachedItem(
             () -> {
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                  final Writer writer =
+                      new BufferedWriter(
+                          new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                 serializer.serialize(checkIn, writer);
                 return stream.toByteArray();
               }
@@ -344,7 +354,9 @@ private static void ensureAttachmentSizeLimit(
               }
 
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                  final Writer writer =
+                      new BufferedWriter(
+                          new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                 serializer.serialize(profileChunk, writer);
                 return stream.toByteArray();
               } catch (IOException e) {
@@ -403,7 +415,9 @@ private static void ensureAttachmentSizeLimit(
               profilingTraceData.readDeviceCpuFrequencies();
 
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                  final Writer writer =
+                      new BufferedWriter(
+                          new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                 serializer.serialize(profilingTraceData, writer);
                 return stream.toByteArray();
               } catch (IOException e) {
@@ -437,7 +451,9 @@ private static void ensureAttachmentSizeLimit(
         new CachedItem(
             () -> {
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                  final Writer writer =
+                      new BufferedWriter(
+                          new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                 serializer.serialize(clientReport, writer);
                 return stream.toByteArray();
               }
@@ -481,7 +497,8 @@ public static SentryEnvelopeItem fromReplay(
               try {
                 try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
                     final Writer writer =
-                        new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                        new BufferedWriter(
+                            new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                   // relay expects the payload to be in this exact order: [event,rrweb,video]
                   final Map<String, byte[]> replayPayload = new LinkedHashMap<>();
                   // first serialize replay event json bytes
@@ -541,7 +558,9 @@ public static SentryEnvelopeItem fromLogs(
         new CachedItem(
             () -> {
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                  final Writer writer =
+                      new BufferedWriter(
+                          new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                 serializer.serialize(logEvents, writer);
                 return stream.toByteArray();
               }
@@ -571,7 +590,9 @@ public static SentryEnvelopeItem fromMetrics(
         new CachedItem(
             () -> {
               try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
-                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                  final Writer writer =
+                      new BufferedWriter(
+                          new OutputStreamWriter(stream, UTF_8), WRITER_BUFFER_SIZE)) {
                 serializer.serialize(metricsEvents, writer);
                 return stream.toByteArray();
               }
diff --git a/sentry/src/main/java/io/sentry/SentryEvent.java b/sentry/src/main/java/io/sentry/SentryEvent.java
index 007d50681fb..8b8575fe7ec 100644
--- a/sentry/src/main/java/io/sentry/SentryEvent.java
+++ b/sentry/src/main/java/io/sentry/SentryEvent.java
@@ -114,7 +114,7 @@ public SentryEvent(final @NotNull Date timestamp) {
 
   @SuppressWarnings({"JdkObsolete", "JavaUtilDate"})
   public Date getTimestamp() {
-    return (Date) timestamp.clone();
+    return timestamp;
   }
 
   public void setTimestamp(final @NotNull Date timestamp) {
diff --git a/sentry/src/main/java/io/sentry/Session.java b/sentry/src/main/java/io/sentry/Session.java
index 3ce2d70e89e..2fdfffb35d9 100644
--- a/sentry/src/main/java/io/sentry/Session.java
+++ b/sentry/src/main/java/io/sentry/Session.java
@@ -131,10 +131,7 @@ public boolean isTerminated() {
 
   @SuppressWarnings({"JdkObsolete", "JavaUtilDate"})
   public @Nullable Date getStarted() {
-    if (started == null) {
-      return null;
-    }
-    return (Date) started.clone();
+    return started;
   }
 
   public @Nullable String getDistinctId() {
@@ -193,8 +190,7 @@ public int errorCount() {
 
   @SuppressWarnings({"JdkObsolete", "JavaUtilDate"})
   public @Nullable Date getTimestamp() {
-    final Date timestampRef = timestamp;
-    return timestampRef != null ? (Date) timestampRef.clone() : null;
+    return timestamp;
   }
 
   /** Ends a session and update its values */
diff --git a/sentry/src/main/java/io/sentry/protocol/App.java b/sentry/src/main/java/io/sentry/protocol/App.java
index 989c3464be8..878ad0ec960 100644
--- a/sentry/src/main/java/io/sentry/protocol/App.java
+++ b/sentry/src/main/java/io/sentry/protocol/App.java
@@ -98,8 +98,7 @@ public void setAppIdentifier(final @Nullable String appIdentifier) {
 
   @SuppressWarnings({"JdkObsolete", "JavaUtilDate"})
   public @Nullable Date getAppStartTime() {
-    final Date appStartTimeRef = appStartTime;
-    return appStartTimeRef != null ? (Date) appStartTimeRef.clone() : null;
+    return appStartTime;
   }
 
   public void setAppStartTime(final @Nullable Date appStartTime) {
diff --git a/sentry/src/main/java/io/sentry/protocol/Contexts.java b/sentry/src/main/java/io/sentry/protocol/Contexts.java
index 35168e5bcc2..83a770eb0fc 100644
--- a/sentry/src/main/java/io/sentry/protocol/Contexts.java
+++ b/sentry/src/main/java/io/sentry/protocol/Contexts.java
@@ -10,14 +10,13 @@
 import io.sentry.ProfileContext;
 import io.sentry.SpanContext;
 import io.sentry.util.AutoClosableReentrantLock;
+import io.sentry.util.CollectionUtils;
 import io.sentry.util.HintUtils;
 import io.sentry.util.Objects;
 import io.sentry.vendor.gson.stream.JsonToken;
 import java.io.IOException;
-import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -302,8 +301,7 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
       throws IOException {
     writer.beginObject();
     // Serialize in alphabetical order to keep determinism.
-    final List<String> sortedKeys = Collections.list(keys());
-    Collections.sort(sortedKeys);
+    final String[] sortedKeys = CollectionUtils.toSortedStringArray(keys(), internalStorage.size());
     for (final String key : sortedKeys) {
       final Object value = get(key);
       if (value != null) {
diff --git a/sentry/src/main/java/io/sentry/protocol/Device.java b/sentry/src/main/java/io/sentry/protocol/Device.java
index e6113efbcb5..5b765640a39 100644
--- a/sentry/src/main/java/io/sentry/protocol/Device.java
+++ b/sentry/src/main/java/io/sentry/protocol/Device.java
@@ -366,8 +366,7 @@ public void setScreenDpi(final @Nullable Integer screenDpi) {
 
   @SuppressWarnings({"JdkObsolete", "JavaUtilDate"})
   public @Nullable Date getBootTime() {
-    final Date bootTimeRef = bootTime;
-    return bootTimeRef != null ? (Date) bootTimeRef.clone() : null;
+    return bootTime;
   }
 
   public void setBootTime(final @Nullable Date bootTime) {
diff --git a/sentry/src/main/java/io/sentry/util/CollectionUtils.java b/sentry/src/main/java/io/sentry/util/CollectionUtils.java
index 266055fa1ce..5b00eb6531c 100644
--- a/sentry/src/main/java/io/sentry/util/CollectionUtils.java
+++ b/sentry/src/main/java/io/sentry/util/CollectionUtils.java
@@ -1,7 +1,9 @@
 package io.sentry.util;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.List;
 import java.util.ListIterator;
@@ -15,9 +17,28 @@
 /** Util class for Collections */
 @ApiStatus.Internal
 public final class CollectionUtils {
+  private static final String[] EMPTY_STRINGS = new String[0];
 
   private CollectionUtils() {}
 
+  public static @NotNull String[] toSortedStringArray(
+      final @NotNull Enumeration<String> source, final int size) {
+    String[] sorted = size == 0 ? EMPTY_STRINGS : new String[size];
+    int index = 0;
+    while (source.hasMoreElements()) {
+      if (index == sorted.length) {
+        sorted = Arrays.copyOf(sorted, sorted.length + 1);
+      }
+      sorted[index] = source.nextElement();
+      index++;
+    }
+    if (index != sorted.length) {
+      sorted = Arrays.copyOf(sorted, index);
+    }
+    Arrays.sort(sorted);
+    return sorted;
+  }
+
   /**
    * Returns an Iterator size
    *
diff --git a/sentry/src/main/java/io/sentry/util/Platform.java b/sentry/src/main/java/io/sentry/util/Platform.java
index cc924fb2815..ad2a4e7f3c3 100644
--- a/sentry/src/main/java/io/sentry/util/Platform.java
+++ b/sentry/src/main/java/io/sentry/util/Platform.java
@@ -20,16 +20,21 @@ public final class Platform {
       isAndroid = false;
     }
 
-    try {
-      final @Nullable String javaStringVersion = System.getProperty("java.specification.version");
-      if (javaStringVersion != null) {
-        final @NotNull double javaVersion = Double.parseDouble(javaStringVersion);
-        isJavaNinePlus = javaVersion >= 9.0;
-      } else {
+    if (isAndroid) {
+      // Android is never Java 9+, skip the system property lookup + parse on the startup path.
+      isJavaNinePlus = false;
+    } else {
+      try {
+        final @Nullable String javaStringVersion = System.getProperty("java.specification.version");
+        if (javaStringVersion != null) {
+          final @NotNull double javaVersion = Double.parseDouble(javaStringVersion);
+          isJavaNinePlus = javaVersion >= 9.0;
+        } else {
+          isJavaNinePlus = false;
+        }
+      } catch (Throwable e) {
         isJavaNinePlus = false;
       }
-    } catch (Throwable e) {
-      isJavaNinePlus = false;
     }
   }
 
diff --git a/sentry/src/main/java/io/sentry/vendor/SentryIso8601Utils.java b/sentry/src/main/java/io/sentry/vendor/SentryIso8601Utils.java
new file mode 100644
index 00000000000..b5cb1811aa9
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/vendor/SentryIso8601Utils.java
@@ -0,0 +1,397 @@
+// Civil date conversion algorithms adapted from Howard Hinnant's date algorithms.
+// Placed in the public domain by Howard Hinnant.
+// https://howardhinnant.github.io/date_algorithms.html
+
+package io.sentry.vendor;
+
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.SimpleTimeZone;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+@ApiStatus.Internal
+public final class SentryIso8601Utils {
+
+  private static final long MILLIS_PER_SECOND = 1000L;
+  private static final long MILLIS_PER_MINUTE = 60L * MILLIS_PER_SECOND;
+  private static final long MILLIS_PER_HOUR = 60L * MILLIS_PER_MINUTE;
+  private static final long MILLIS_PER_DAY = 24L * MILLIS_PER_HOUR;
+  private static final long GREGORIAN_CUTOVER_MILLIS = -12219292800000L;
+  private static final int DAYS_0000_TO_1970 = 719468;
+
+  private SentryIso8601Utils() {}
+
+  public static long parseTimestamp(final @NotNull String timestamp) {
+    final int length = timestamp.length();
+    int offset = 0;
+
+    final int year = parseInt(timestamp, offset, offset += 4);
+    if (checkOffset(timestamp, offset, '-')) {
+      offset++;
+    }
+
+    final int month = parseInt(timestamp, offset, offset += 2);
+    if (checkOffset(timestamp, offset, '-')) {
+      offset++;
+    }
+
+    final int day = parseInt(timestamp, offset, offset += 2);
+
+    if (!checkOffset(timestamp, offset, 'T')) {
+      if (offset == length) {
+        return dateOnlyEpochMillis(year, month, day);
+      }
+      final char timezoneIndicator = timestamp.charAt(offset);
+      if (timezoneIndicator == 'Z' || timezoneIndicator == '+' || timezoneIndicator == '-') {
+        return dateOnlyEpochMillisWithTimezone(timestamp, length, offset, year, month, day);
+      }
+      throw new IllegalArgumentException("Invalid date separator");
+    }
+    validateDate(year, month, day);
+    offset++;
+
+    final int hour = parseInt(timestamp, offset, offset += 2);
+    if (checkOffset(timestamp, offset, ':')) {
+      offset++;
+    }
+
+    final int minute = parseInt(timestamp, offset, offset += 2);
+    if (checkOffset(timestamp, offset, ':')) {
+      offset++;
+    }
+
+    int second = 0;
+    int millisecond = 0;
+    if (length > offset) {
+      final char c = timestamp.charAt(offset);
+      if (c != 'Z' && c != '+' && c != '-') {
+        second = parseInt(timestamp, offset, offset += 2);
+        if (second > 59 && second < 63) {
+          second = 59;
+        }
+        if (checkOffset(timestamp, offset, '.')) {
+          offset++;
+          final int endOffset = indexOfNonDigit(timestamp, offset);
+          if (endOffset == offset) {
+            throw new IllegalArgumentException("Missing millisecond digits");
+          }
+          final int parseEndOffset = Math.min(endOffset, offset + 3);
+          final int fraction = parseInt(timestamp, offset, parseEndOffset);
+          switch (parseEndOffset - offset) {
+            case 1:
+              millisecond = fraction * 100;
+              break;
+            case 2:
+              millisecond = fraction * 10;
+              break;
+            default:
+              millisecond = fraction;
+              break;
+          }
+          offset = endOffset;
+        }
+      }
+    }
+    validateTime(hour, minute, second, millisecond);
+
+    if (length <= offset) {
+      throw new IllegalArgumentException("No time zone indicator");
+    }
+
+    final int timezoneOffsetMillis;
+    final boolean allowTrailingCharacters;
+    final char timezoneIndicator = timestamp.charAt(offset);
+    if (timezoneIndicator == 'Z') {
+      timezoneOffsetMillis = 0;
+      offset++;
+      allowTrailingCharacters = true;
+    } else if (timezoneIndicator == '+' || timezoneIndicator == '-') {
+      final int sign = timezoneIndicator == '+' ? 1 : -1;
+      offset++;
+      final int timezoneHour = parseInt(timestamp, offset, offset += 2);
+      int timezoneMinute = 0;
+      if (checkOffset(timestamp, offset, ':')) {
+        offset++;
+      }
+      if (length >= offset + 2) {
+        timezoneMinute = parseInt(timestamp, offset, offset += 2);
+      }
+      validateTimezone(timezoneHour, timezoneMinute);
+      timezoneOffsetMillis =
+          sign * (int) (timezoneHour * MILLIS_PER_HOUR + timezoneMinute * MILLIS_PER_MINUTE);
+      allowTrailingCharacters = false;
+    } else {
+      throw new IllegalArgumentException("Invalid time zone indicator");
+    }
+
+    if (!allowTrailingCharacters && offset != length) {
+      throw new IllegalArgumentException("Invalid trailing characters");
+    }
+
+    if (isBeforeGregorianCutover(year, month, day)) {
+      return epochMillisWithCalendar(
+          year, month, day, hour, minute, second, millisecond, timezoneOffsetMillis);
+    }
+
+    return epochMillis(year, month, day, hour, minute, second, millisecond, timezoneOffsetMillis);
+  }
+
+  public static @NotNull String formatTimestamp(final long millis) {
+    if (millis < GREGORIAN_CUTOVER_MILLIS) {
+      return formatTimestampWithCalendar(millis);
+    }
+
+    final long epochDay = Math.floorDiv(millis, MILLIS_PER_DAY);
+    int millisOfDay = (int) Math.floorMod(millis, MILLIS_PER_DAY);
+
+    final int[] yearMonthDay = epochDayToYearMonthDay(epochDay);
+    final int hour = millisOfDay / (int) MILLIS_PER_HOUR;
+    millisOfDay -= hour * (int) MILLIS_PER_HOUR;
+    final int minute = millisOfDay / (int) MILLIS_PER_MINUTE;
+    millisOfDay -= minute * (int) MILLIS_PER_MINUTE;
+    final int second = millisOfDay / (int) MILLIS_PER_SECOND;
+    final int millisecond = millisOfDay - second * (int) MILLIS_PER_SECOND;
+
+    final StringBuilder timestamp = new StringBuilder("yyyy-MM-ddThh:mm:ss.sssZ".length());
+    padInt(timestamp, yearMonthDay[0], "yyyy".length());
+    timestamp.append('-');
+    padInt(timestamp, yearMonthDay[1], "MM".length());
+    timestamp.append('-');
+    padInt(timestamp, yearMonthDay[2], "dd".length());
+    timestamp.append('T');
+    padInt(timestamp, hour, "hh".length());
+    timestamp.append(':');
+    padInt(timestamp, minute, "mm".length());
+    timestamp.append(':');
+    padInt(timestamp, second, "ss".length());
+    timestamp.append('.');
+    padInt(timestamp, millisecond, "sss".length());
+    timestamp.append('Z');
+    return timestamp.toString();
+  }
+
+  private static long dateOnlyEpochMillis(final int year, final int month, final int day) {
+    return new GregorianCalendar(year, month - 1, day).getTimeInMillis();
+  }
+
+  private static long dateOnlyEpochMillisWithTimezone(
+      final @NotNull String timestamp,
+      final int length,
+      int offset,
+      final int year,
+      final int month,
+      final int day) {
+    final int timezoneOffsetMillis;
+    final boolean allowTrailingCharacters;
+    final char timezoneIndicator = timestamp.charAt(offset);
+    if (timezoneIndicator == 'Z') {
+      timezoneOffsetMillis = 0;
+      offset++;
+      allowTrailingCharacters = true;
+    } else if (timezoneIndicator == '+' || timezoneIndicator == '-') {
+      final int sign = timezoneIndicator == '+' ? 1 : -1;
+      offset++;
+      final int timezoneHour = parseInt(timestamp, offset, offset += 2);
+      int timezoneMinute = 0;
+      if (checkOffset(timestamp, offset, ':')) {
+        offset++;
+      }
+      if (length >= offset + 2) {
+        timezoneMinute = parseInt(timestamp, offset, offset += 2);
+      }
+      validateTimezone(timezoneHour, timezoneMinute);
+      timezoneOffsetMillis =
+          sign * (int) (timezoneHour * MILLIS_PER_HOUR + timezoneMinute * MILLIS_PER_MINUTE);
+      allowTrailingCharacters = false;
+    } else {
+      throw new IllegalArgumentException("Invalid time zone indicator");
+    }
+
+    if (!allowTrailingCharacters && offset != length) {
+      throw new IllegalArgumentException("Invalid trailing characters");
+    }
+
+    if (isBeforeGregorianCutover(year, month, day)) {
+      return epochMillisWithCalendar(year, month, day, 0, 0, 0, 0, timezoneOffsetMillis);
+    }
+    validateDate(year, month, day);
+    return epochMillis(year, month, day, 0, 0, 0, 0, timezoneOffsetMillis);
+  }
+
+  private static long epochMillisWithCalendar(
+      final int year,
+      final int month,
+      final int day,
+      final int hour,
+      final int minute,
+      final int second,
+      final int millisecond,
+      final int timezoneOffsetMillis) {
+    final GregorianCalendar calendar = new GregorianCalendar(new SimpleTimeZone(timezoneOffsetMillis, "GMT"));
+    calendar.setLenient(false);
+    calendar.set(Calendar.YEAR, year);
+    calendar.set(Calendar.MONTH, month - 1);
+    calendar.set(Calendar.DAY_OF_MONTH, day);
+    calendar.set(Calendar.HOUR_OF_DAY, hour);
+    calendar.set(Calendar.MINUTE, minute);
+    calendar.set(Calendar.SECOND, second);
+    calendar.set(Calendar.MILLISECOND, millisecond);
+    return calendar.getTimeInMillis();
+  }
+
+  private static @NotNull String formatTimestampWithCalendar(final long millis) {
+    final GregorianCalendar calendar = new GregorianCalendar(new SimpleTimeZone(0, "UTC"));
+    calendar.setTimeInMillis(millis);
+
+    final StringBuilder timestamp = new StringBuilder("yyyy-MM-ddThh:mm:ss.sssZ".length());
+    padInt(timestamp, calendar.get(Calendar.YEAR), "yyyy".length());
+    timestamp.append('-');
+    padInt(timestamp, calendar.get(Calendar.MONTH) + 1, "MM".length());
+    timestamp.append('-');
+    padInt(timestamp, calendar.get(Calendar.DAY_OF_MONTH), "dd".length());
+    timestamp.append('T');
+    padInt(timestamp, calendar.get(Calendar.HOUR_OF_DAY), "hh".length());
+    timestamp.append(':');
+    padInt(timestamp, calendar.get(Calendar.MINUTE), "mm".length());
+    timestamp.append(':');
+    padInt(timestamp, calendar.get(Calendar.SECOND), "ss".length());
+    timestamp.append('.');
+    padInt(timestamp, calendar.get(Calendar.MILLISECOND), "sss".length());
+    timestamp.append('Z');
+    return timestamp.toString();
+  }
+
+  private static long epochMillis(
+      final int year,
+      final int month,
+      final int day,
+      final int hour,
+      final int minute,
+      final int second,
+      final int millisecond,
+      final int timezoneOffsetMillis) {
+    return daysFromYearMonthDay(year, month, day) * MILLIS_PER_DAY
+        + hour * MILLIS_PER_HOUR
+        + minute * MILLIS_PER_MINUTE
+        + second * MILLIS_PER_SECOND
+        + millisecond
+        - timezoneOffsetMillis;
+  }
+
+  private static long daysFromYearMonthDay(int year, final int month, final int day) {
+    year -= month <= 2 ? 1 : 0;
+    final long era = Math.floorDiv(year, 400);
+    final int yearOfEra = (int) (year - era * 400);
+    final int dayOfYear = (153 * (month + (month > 2 ? -3 : 9)) + 2) / 5 + day - 1;
+    final int dayOfEra = yearOfEra * 365 + yearOfEra / 4 - yearOfEra / 100 + dayOfYear;
+    return era * 146097 + dayOfEra - DAYS_0000_TO_1970;
+  }
+
+  private static int[] epochDayToYearMonthDay(long epochDay) {
+    epochDay += DAYS_0000_TO_1970;
+    final long era = Math.floorDiv(epochDay, 146097);
+    final int dayOfEra = (int) (epochDay - era * 146097);
+    final int yearOfEra = (dayOfEra - dayOfEra / 1460 + dayOfEra / 36524 - dayOfEra / 146096) / 365;
+    final int year = (int) (yearOfEra + era * 400);
+    final int dayOfYear = dayOfEra - (365 * yearOfEra + yearOfEra / 4 - yearOfEra / 100);
+    final int monthPrime = (5 * dayOfYear + 2) / 153;
+    final int day = dayOfYear - (153 * monthPrime + 2) / 5 + 1;
+    final int month = monthPrime < 10 ? monthPrime + 3 : monthPrime - 9;
+    return new int[] {year + (month <= 2 ? 1 : 0), month, day};
+  }
+
+  private static boolean isBeforeGregorianCutover(final int year, final int month, final int day) {
+    return year < 1582 || (year == 1582 && (month < 10 || (month == 10 && day < 15)));
+  }
+
+  private static void validateDate(final int year, final int month, final int day) {
+    if (year < 1 || month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month)) {
+      throw new IllegalArgumentException("Invalid date");
+    }
+  }
+
+  private static void validateTime(
+      final int hour, final int minute, final int second, final int millisecond) {
+    if (hour < 0
+        || hour > 23
+        || minute < 0
+        || minute > 59
+        || second < 0
+        || second > 59
+        || millisecond < 0
+        || millisecond > 999) {
+      throw new IllegalArgumentException("Invalid time");
+    }
+  }
+
+  private static void validateTimezone(final int hour, final int minute) {
+    if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+      throw new IllegalArgumentException("Invalid time zone");
+    }
+  }
+
+  private static int daysInMonth(final int year, final int month) {
+    switch (month) {
+      case 2:
+        return isLeapYear(year) ? 29 : 28;
+      case 4:
+      case 6:
+      case 9:
+      case 11:
+        return 30;
+      default:
+        return 31;
+    }
+  }
+
+  private static boolean isLeapYear(final int year) {
+    return (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0);
+  }
+
+  private static boolean checkOffset(
+      final @NotNull String value, final int offset, final char expected) {
+    return offset < value.length() && value.charAt(offset) == expected;
+  }
+
+  private static int parseInt(
+      final @NotNull String value, final int beginIndex, final int endIndex) {
+    if (beginIndex < 0 || endIndex > value.length() || beginIndex >= endIndex) {
+      throw new NumberFormatException(value);
+    }
+
+    int result = 0;
+    for (int i = beginIndex; i < endIndex; i++) {
+      final char c = value.charAt(i);
+      if (c < '0' || c > '9') {
+        throw new NumberFormatException("Invalid number: " + value.substring(beginIndex, endIndex));
+      }
+      result = result * 10 + c - '0';
+    }
+    return result;
+  }
+
+  private static void padInt(
+      final @NotNull StringBuilder buffer, final int value, final int length) {
+    if (value < 0) {
+      buffer.append('-');
+      padInt(buffer, -value, length);
+      return;
+    }
+    final String strValue = Integer.toString(value);
+    for (int i = length - strValue.length(); i > 0; i--) {
+      buffer.append('0');
+    }
+    buffer.append(strValue);
+  }
+
+  private static int indexOfNonDigit(final @NotNull String string, final int offset) {
+    for (int i = offset; i < string.length(); i++) {
+      final char c = string.charAt(i);
+      if (c < '0' || c > '9') {
+        return i;
+      }
+    }
+    return string.length();
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/vendor/gson/stream/JsonWriter.java b/sentry/src/main/java/io/sentry/vendor/gson/stream/JsonWriter.java
index b030bc174b7..3119c833fd2 100644
--- a/sentry/src/main/java/io/sentry/vendor/gson/stream/JsonWriter.java
+++ b/sentry/src/main/java/io/sentry/vendor/gson/stream/JsonWriter.java
@@ -17,7 +17,7 @@
 // Source: https://github.com/google/gson
 // Tag: gson-parent-2.8.7
 // Commit Hash: 4520489c29e770c64b11ca35e0a0fdf17a1874ab
-// Changes: @ApiStatus.Internal, SuppressWarnings
+// Changes: @ApiStatus.Internal, SuppressWarnings, reduced stack size
 
 package io.sentry.vendor.gson.stream;
 
@@ -175,7 +175,7 @@ public class JsonWriter implements Closeable, Flushable {
   /** The output data, containing at most one top-level array or object. */
   private final Writer out;
 
-  private int[] stack = new int[32];
+  private int[] stack = new int[8];
   private int stackSize = 0;
   {
     push(EMPTY_DOCUMENT);
diff --git a/sentry/src/test/java/io/sentry/BreadcrumbTest.kt b/sentry/src/test/java/io/sentry/BreadcrumbTest.kt
index 30c322641b8..f51acca81cb 100644
--- a/sentry/src/test/java/io/sentry/BreadcrumbTest.kt
+++ b/sentry/src/test/java/io/sentry/BreadcrumbTest.kt
@@ -1,6 +1,9 @@
 package io.sentry
 
 import java.util.Date
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -329,6 +332,39 @@ class BreadcrumbTest {
     breadcrumb.removeData(null)
   }
 
+  @Test
+  fun `getData returns mutable map for new breadcrumb`() {
+    val breadcrumb = Breadcrumb()
+
+    breadcrumb.data["k"] = "v"
+
+    assertEquals("v", breadcrumb.getData("k"))
+  }
+
+  @Test
+  fun `concurrent first writes keep all data entries`() {
+    val breadcrumb = Breadcrumb()
+    val count = 32
+    val executor = Executors.newFixedThreadPool(count)
+    val start = CountDownLatch(1)
+    val futures =
+      (0 until count).map { index ->
+        executor.submit {
+          start.await()
+          breadcrumb.setData("key-$index", index)
+        }
+      }
+
+    start.countDown()
+    futures.forEach { it.get(5, TimeUnit.SECONDS) }
+    executor.shutdown()
+
+    assertEquals(count, breadcrumb.data.size)
+    for (index in 0 until count) {
+      assertEquals(index, breadcrumb.data["key-$index"])
+    }
+  }
+
   class TestKey(val id: Long) {
     override fun toString(): String = id.toString()
   }
diff --git a/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt b/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt
index d768d6d32d6..fd187235a92 100644
--- a/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt
+++ b/sentry/src/test/java/io/sentry/CombinedScopeViewTest.kt
@@ -11,6 +11,7 @@ import junit.framework.TestCase.assertTrue
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
+import kotlin.test.assertNotSame
 import kotlin.test.assertNull
 import kotlin.test.assertSame
 import org.junit.Assert.assertNotEquals
@@ -72,6 +73,74 @@ class CombinedScopeViewTest {
     assertEquals("current 2", breadcrumbs.poll().message)
   }
 
+  @Test
+  fun `returns single non-empty breadcrumb queue directly`() {
+    var combined = fixture.getSut()
+    fixture.globalScope.addBreadcrumb(Breadcrumb.info("global"))
+    assertSame(fixture.globalScope.breadcrumbs, combined.breadcrumbs)
+
+    combined = fixture.getSut()
+    fixture.isolationScope.addBreadcrumb(Breadcrumb.info("isolation"))
+    assertSame(fixture.isolationScope.breadcrumbs, combined.breadcrumbs)
+
+    combined = fixture.getSut()
+    fixture.scope.addBreadcrumb(Breadcrumb.info("current"))
+    assertSame(fixture.scope.breadcrumbs, combined.breadcrumbs)
+  }
+
+  @Test
+  fun `returns default write scope breadcrumbs when all scopes are empty`() {
+    val combined = fixture.getSut(SentryOptions().also { it.defaultScopeType = ScopeType.CURRENT })
+
+    assertSame(fixture.scope.breadcrumbs, combined.breadcrumbs)
+  }
+
+  @Test
+  fun `returns merged breadcrumb copy when multiple scopes have breadcrumbs`() {
+    val combined = fixture.getSut()
+
+    fixture.globalScope.addBreadcrumb(Breadcrumb.info("global"))
+    fixture.isolationScope.addBreadcrumb(Breadcrumb.info("isolation"))
+
+    val breadcrumbs = combined.breadcrumbs
+
+    assertNotSame(fixture.globalScope.breadcrumbs, breadcrumbs)
+    assertNotSame(fixture.isolationScope.breadcrumbs, breadcrumbs)
+    assertEquals(2, breadcrumbs.size)
+  }
+
+  @Test
+  fun `returns single non-empty combined collections directly`() {
+    val globalScope = mock<IScope>()
+    val isolationScope = mock<IScope>()
+    val scope = mock<IScope>()
+    val combined = CombinedScopeView(globalScope, isolationScope, scope)
+
+    val tags = mapOf("tag" to "value")
+    whenever(globalScope.tags).thenReturn(emptyMap())
+    whenever(isolationScope.tags).thenReturn(emptyMap())
+    whenever(scope.tags).thenReturn(tags)
+    assertSame(tags, combined.tags)
+
+    val attributes = mapOf("attribute" to SentryAttribute.named("attribute", "value"))
+    whenever(globalScope.attributes).thenReturn(emptyMap())
+    whenever(isolationScope.attributes).thenReturn(emptyMap())
+    whenever(scope.attributes).thenReturn(attributes)
+    assertSame(attributes, combined.attributes)
+
+    val extras = mapOf<String, Any>("extra" to "value")
+    whenever(globalScope.extras).thenReturn(emptyMap())
+    whenever(isolationScope.extras).thenReturn(emptyMap())
+    whenever(scope.extras).thenReturn(extras)
+    assertSame(extras, combined.extras)
+
+    val attachments = listOf(createAttachment("attachment.png"))
+    whenever(globalScope.attachments).thenReturn(emptyList())
+    whenever(isolationScope.attachments).thenReturn(emptyList())
+    whenever(scope.attachments).thenReturn(attachments)
+    assertSame(attachments, combined.attachments)
+  }
+
   @Test
   fun `oldest breadcrumbs are dropped first`() {
     val options = SentryOptions().also { it.maxBreadcrumbs = 5 }
diff --git a/sentry/src/test/java/io/sentry/DateUtilsTest.kt b/sentry/src/test/java/io/sentry/DateUtilsTest.kt
index 9e234b50c1b..97882198e62 100644
--- a/sentry/src/test/java/io/sentry/DateUtilsTest.kt
+++ b/sentry/src/test/java/io/sentry/DateUtilsTest.kt
@@ -1,12 +1,16 @@
 package io.sentry
 
+import io.sentry.vendor.gson.internal.bind.util.ISO8601Utils
+import java.text.ParsePosition
 import java.time.Instant
 import java.time.LocalDateTime
 import java.time.ZoneId
 import java.time.format.DateTimeFormatter
 import java.util.Date
+import java.util.TimeZone
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
@@ -34,6 +38,54 @@ class DateUtilsTest {
     assertEquals("2020-03-27T08:52:58.000Z", timestamp)
   }
 
+  @Test
+  fun `When ISO date has offset`() {
+    val input =
+      mapOf(
+        "2020-03-27T10:52:58.015+02:00" to "2020-03-27T08:52:58.015Z",
+        "2020-03-27T10:52:58.015+0200" to "2020-03-27T08:52:58.015Z",
+        "2020-03-27T10:52:58.015+02" to "2020-03-27T08:52:58.015Z",
+        "2020-03-27T05:52:58.015-03:00" to "2020-03-27T08:52:58.015Z",
+      )
+
+    input.forEach {
+      val timestamp = convertDate(DateUtils.getDateTime(it.key)).format(isoFormat)
+
+      assertEquals(it.value, timestamp)
+    }
+  }
+
+  @Test
+  fun `When ISO date uses compact separators`() {
+    val date = DateUtils.getDateTime("20200327T085258.015Z")
+
+    val utcDate = convertDate(date)
+    val timestamp = utcDate.format(isoFormat)
+
+    assertEquals("2020-03-27T08:52:58.015Z", timestamp)
+  }
+
+  @Test
+  fun `When ISO date has short fraction`() {
+    val input =
+      mapOf(
+        "2020-03-27T08:52:58.1Z" to "2020-03-27T08:52:58.100Z",
+        "2020-03-27T08:52:58.12Z" to "2020-03-27T08:52:58.120Z",
+        "2020-03-27T08:52:58.123456Z" to "2020-03-27T08:52:58.123Z",
+      )
+
+    input.forEach {
+      val timestamp = convertDate(DateUtils.getDateTime(it.key)).format(isoFormat)
+
+      assertEquals(it.value, timestamp)
+    }
+  }
+
+  @Test
+  fun `When ISO date is invalid`() {
+    assertFailsWith<IllegalArgumentException> { DateUtils.getDateTime("2020-02-30T08:52:58Z") }
+  }
+
   @Test
   fun `Converts from Date to ISO 8601 and back to Date`() {
     val currentDate = DateUtils.getCurrentDateTime()
@@ -78,6 +130,147 @@ class DateUtilsTest {
     assertTrue { utcCurrentDate.minusSeconds(1).isBefore(utcDate) }
   }
 
+  @Test
+  fun `Formats millis to ISO 8601 timestamp`() {
+    val input =
+      mapOf(
+        Instant.parse("1970-01-01T00:00:00.000Z").toEpochMilli() to "1970-01-01T00:00:00.000Z",
+        Instant.parse("1969-12-31T23:59:59.999Z").toEpochMilli() to "1969-12-31T23:59:59.999Z",
+        Instant.parse("2000-02-29T12:34:56.789Z").toEpochMilli() to "2000-02-29T12:34:56.789Z",
+        Instant.parse("1900-03-01T00:00:00.000Z").toEpochMilli() to "1900-03-01T00:00:00.000Z",
+        Instant.parse("2100-03-01T00:00:00.000Z").toEpochMilli() to "2100-03-01T00:00:00.000Z",
+        Instant.parse("2400-02-29T23:59:59.999Z").toEpochMilli() to "2400-02-29T23:59:59.999Z",
+      )
+
+    input.forEach { assertEquals(it.value, DateUtils.getTimestampFromMillis(it.key)) }
+  }
+
+  @Test
+  fun `Fast timestamp formatter matches previous ISO8601 formatter`() {
+    val input =
+      listOf(
+        "1582-10-04T00:00:00.000Z",
+        "1582-10-15T00:00:00.000Z",
+        "1900-03-01T00:00:00.000Z",
+        "1969-12-31T23:59:59.999Z",
+        "1970-01-01T00:00:00.000Z",
+        "1999-12-31T23:59:59.999Z",
+        "2000-02-29T12:34:56.789Z",
+        "2020-03-27T08:52:58.015Z",
+        "2024-02-29T23:59:59.001Z",
+        "2100-03-01T00:00:00.000Z",
+        "2400-02-29T23:59:59.999Z",
+      )
+
+    input
+      .map { ISO8601Utils.parse(it, ParsePosition(0)).time }
+      .forEach {
+        assertEquals(
+          ISO8601Utils.format(Date(it), true),
+          DateUtils.getTimestampFromMillis(it),
+          "millis=$it",
+        )
+      }
+  }
+
+  @Test
+  fun `Fast timestamp parser matches previous ISO8601 parser`() {
+    val input =
+      listOf(
+        "2020-03-27T08:52Z",
+        "2020-03-27T08:52:58Z",
+        "2020-03-27T08:52:58.015Z",
+        "20200327T085258.015Z",
+        "2020-03-27T10:52:58.015+02:00",
+        "2020-03-27T10:52:58.015+0200",
+        "2020-03-27T10:52:58.015+02",
+        "2020-03-27T05:52:58.015-03:00",
+        "2020-03-27T05:22:58.015-0330",
+        "2020-03-27T08:52:58.1Z",
+        "2020-03-27T08:52:58.12Z",
+        "2020-03-27T08:52:58.123456Z",
+        "2020-03-27T08:52:58Ztrailing",
+        "2016-12-31T23:59:60Z",
+        "1582-10-04T00:00:00.000Z",
+        "1582-10-15T00:00:00.000Z",
+        "1900-03-01T00:00:00.000Z",
+        "2000-02-29T12:34:56.789Z",
+        "2100-03-01T00:00:00.000Z",
+      )
+
+    input.forEach {
+      assertEquals(
+        ISO8601Utils.parse(it, ParsePosition(0)).time,
+        DateUtils.getDateTime(it).time,
+        "timestamp=$it",
+      )
+    }
+  }
+
+  @Test
+  fun `Fast timestamp parser matches previous ISO8601 parser for date-only values`() {
+    withDefaultTimeZone("America/Los_Angeles") {
+      val input = listOf("2020-03-27", "20200327", "2020-02-30")
+
+      input.forEach {
+        assertEquals(
+          ISO8601Utils.parse(it, ParsePosition(0)).time,
+          DateUtils.getDateTime(it).time,
+          "timestamp=$it",
+        )
+      }
+    }
+  }
+
+  @Test
+  fun `Fast timestamp parser matches previous ISO8601 parser for date-only values with timezone`() {
+    val input =
+      listOf(
+        "2020-03-27Z",
+        "2020-03-27+02:00",
+        "2020-03-27+0200",
+        "2020-03-27+02",
+        "2020-03-27-03:30",
+        "20200327Z",
+        "20200327+02:00",
+        "20200327-0330",
+      )
+
+    input.forEach {
+      assertEquals(
+        ISO8601Utils.parse(it, ParsePosition(0)).time,
+        DateUtils.getDateTime(it).time,
+        "timestamp=$it",
+      )
+    }
+  }
+
+  @Test
+  fun `Fast timestamp parser rejects invalid date-only values with timezone like previous ISO8601 parser`() {
+    val timestamp = "2020-02-30Z"
+
+    assertFailsWith<Exception> { ISO8601Utils.parse(timestamp, ParsePosition(0)) }
+    assertFailsWith<IllegalArgumentException> { DateUtils.getDateTime(timestamp) }
+  }
+
+  @Test
+  fun `Fast timestamp parser rejects date-time without timezone like previous ISO8601 parser`() {
+    val input = listOf("2020-03-27T08:52", "2020-03-27T08:52:58", "2020-03-27T08:52:58.015")
+
+    input.forEach {
+      assertFailsWith<Exception>("timestamp=$it") { ISO8601Utils.parse(it, ParsePosition(0)) }
+      assertFailsWith<IllegalArgumentException>("timestamp=$it") { DateUtils.getDateTime(it) }
+    }
+  }
+
+  @Test
+  fun `Fast timestamp parser rejects Gregorian cutover gap like previous ISO8601 parser`() {
+    val timestamp = "1582-10-10T00:00:00.000Z"
+
+    assertFailsWith<Exception> { ISO8601Utils.parse(timestamp, ParsePosition(0)) }
+    assertFailsWith<IllegalArgumentException> { DateUtils.getDateTime(timestamp) }
+  }
+
   @Test
   fun `Millis formats to Date`() {
     val millis = 1591533492L * 1000L + 631
@@ -86,6 +279,7 @@ class DateUtilsTest {
     val utcActual = convertDate(actual)
     val timestamp = utcActual.format(isoFormat)
 
+    assertEquals(millis, actual.time)
     assertEquals("2020-06-07T12:38:12.631Z", timestamp)
   }
 
@@ -120,6 +314,16 @@ class DateUtilsTest {
   private fun convertDate(date: Date): LocalDateTime =
     Instant.ofEpochMilli(date.time).atZone(utcTimeZone).toLocalDateTime()
 
+  private fun withDefaultTimeZone(timeZoneId: String, block: () -> Unit) {
+    val previousTimeZone = TimeZone.getDefault()
+    try {
+      TimeZone.setDefault(TimeZone.getTimeZone(timeZoneId))
+      block()
+    } finally {
+      TimeZone.setDefault(previousTimeZone)
+    }
+  }
+
   private fun assertClose(expected: Double, actual: Double?) {
     assertNotNull(actual)
     val diff = Math.abs(expected - actual)
diff --git a/sentry/src/test/java/io/sentry/JsonObjectSerializerTest.kt b/sentry/src/test/java/io/sentry/JsonObjectSerializerTest.kt
index 3323be84cda..572c27abced 100644
--- a/sentry/src/test/java/io/sentry/JsonObjectSerializerTest.kt
+++ b/sentry/src/test/java/io/sentry/JsonObjectSerializerTest.kt
@@ -7,6 +7,8 @@ import java.util.Locale
 import java.util.TimeZone
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicIntegerArray
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
 import org.junit.Test
 import org.mockito.kotlin.inOrder
 import org.mockito.kotlin.mock
@@ -192,6 +194,21 @@ internal class JsonObjectSerializerTest {
     verify(jsonSerializable).serialize(fixture.writer, fixture.logger)
   }
 
+  @Test
+  fun `serialize json serializable does not create reflection serializer`() {
+    val serializer = fixture.getSUT()
+    val jsonSerializable: JsonSerializable = mock()
+    serializer.serialize(fixture.writer, fixture.logger, jsonSerializable)
+    assertNull(serializer.reflectionObjectSerializer)
+  }
+
+  @Test
+  fun `serialize unknown object creates reflection serializer`() {
+    val serializer = fixture.getSUT()
+    serializer.serialize(fixture.writer, fixture.logger, object {})
+    assertNotNull(serializer.reflectionObjectSerializer)
+  }
+
   @Test
   fun `serialize unknown object without data`() {
     val value = object {}
@@ -355,3 +372,10 @@ internal class JsonObjectSerializerTest {
 data class ClassWithEnumProperty(val enumProperty: DataCategory)
 
 data class ClassWithLocaleProperty(val localeProperty: Locale)
+
+private val JsonObjectSerializer.reflectionObjectSerializer: JsonReflectionObjectSerializer?
+  get() {
+    val field = JsonObjectSerializer::class.java.getDeclaredField("jsonReflectionObjectSerializer")
+    field.isAccessible = true
+    return field.get(this) as JsonReflectionObjectSerializer?
+  }
diff --git a/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt b/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
index 229fd571871..fe5c835c90f 100644
--- a/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
+++ b/sentry/src/test/java/io/sentry/MainEventProcessorTest.kt
@@ -358,6 +358,19 @@ class MainEventProcessorTest {
     }
   }
 
+  @Test
+  fun `options tags are copied when applied to event`() {
+    val sut = fixture.getSut(tags = mapOf("tag1" to "value1"))
+    val event = SentryEvent()
+
+    sut.process(event, Hint())
+    val eventTags = event.tags!!
+
+    fixture.sentryOptions.setTag("tag2", "value2")
+
+    assertFalse(eventTags.containsKey("tag2"))
+  }
+
   @Test
   fun `when event has a tag set with the same name as SentryOptions tags, the tag value from the event is retained`() {
     val sut = fixture.getSut(tags = mapOf("tag1" to "value1", "tag2" to "value2"))
diff --git a/sentry/src/test/java/io/sentry/MonitorContextsTest.kt b/sentry/src/test/java/io/sentry/MonitorContextsTest.kt
new file mode 100644
index 00000000000..2b0d57e605e
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/MonitorContextsTest.kt
@@ -0,0 +1,19 @@
+package io.sentry
+
+import io.sentry.protocol.SerializationUtils
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.mockito.kotlin.mock
+
+class MonitorContextsTest {
+  @Test
+  fun `serializes entries in alphabetical order`() {
+    val contexts =
+      MonitorContexts().apply {
+        put("b", 2)
+        put("a", 1)
+      }
+
+    assertEquals("{\"a\":1,\"b\":2}", SerializationUtils.serializeToString(contexts, mock()))
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index ab6fd2075a3..f51345957e4 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -534,6 +534,24 @@ class SentryClientTest {
     assertNotNull(event.request) { assertEquals("post", it.method) }
   }
 
+  @Test
+  fun `when captureEvent applies scope tags and extras, event map containers are copied`() {
+    val event = SentryEvent()
+    val scope = createScope()
+
+    val sut = fixture.getSut()
+
+    sut.captureEvent(event, scope)
+    val eventTags = event.tags!!
+    val eventExtras = event.extras!!
+
+    scope.setTag("newTag", "newValue")
+    scope.setExtra("newExtra", "newValue")
+
+    assertFalse(eventTags.containsKey("newTag"))
+    assertFalse(eventExtras.containsKey("newExtra"))
+  }
+
   @Test
   fun `when breadcrumbs are not empty, sort them out by date`() {
     val b1 = Breadcrumb(DateUtils.getDateTime("2020-03-27T08:52:58.001Z"))
diff --git a/sentry/src/test/java/io/sentry/protocol/AppTest.kt b/sentry/src/test/java/io/sentry/protocol/AppTest.kt
index 84b4c7088e3..cc0f504b7c8 100644
--- a/sentry/src/test/java/io/sentry/protocol/AppTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/AppTest.kt
@@ -5,10 +5,11 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNotSame
+import kotlin.test.assertSame
 
 class AppTest {
   @Test
-  fun `copying app wont have the same references`() {
+  fun `copying app keeps date reference and copies collections`() {
     val app = App()
     app.appBuild = "app build"
     app.appIdentifier = "app identifier"
@@ -28,7 +29,7 @@ class AppTest {
 
     assertNotNull(clone)
     assertNotSame(app, clone)
-    assertNotSame(app.appStartTime, clone.appStartTime)
+    assertSame(app.appStartTime, clone.appStartTime)
     assertNotSame(app.permissions, clone.permissions)
     assertNotSame(app.viewNames, clone.viewNames)
 
diff --git a/sentry/src/test/java/io/sentry/protocol/BreadcrumbSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/BreadcrumbSerializationTest.kt
index 72856c3c27d..a33ddb91a2b 100644
--- a/sentry/src/test/java/io/sentry/protocol/BreadcrumbSerializationTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/BreadcrumbSerializationTest.kt
@@ -11,6 +11,7 @@ import io.sentry.SentryLevel
 import io.sentry.SentryOptions
 import java.io.StringReader
 import java.io.StringWriter
+import java.util.Date
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 import org.junit.Test
@@ -49,6 +50,13 @@ class BreadcrumbSerializationTest {
     assertEquals(expectedJson, actualJson)
   }
 
+  @Test
+  fun `timestampMs fast path serializes same timestamp as Date fallback`() {
+    val timestampMs = DateUtils.getDateTime("2009-11-16T01:08:47.123Z").time
+
+    assertEquals(serialize(Breadcrumb(Date(timestampMs))), serialize(Breadcrumb(timestampMs)))
+  }
+
   @Test
   fun deserializeFromMap() {
     val map: Map<String, Any?> =
diff --git a/sentry/src/test/java/io/sentry/protocol/DeviceTest.kt b/sentry/src/test/java/io/sentry/protocol/DeviceTest.kt
index 121cbe6537f..a67305c37ea 100644
--- a/sentry/src/test/java/io/sentry/protocol/DeviceTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/DeviceTest.kt
@@ -6,11 +6,12 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNotSame
+import kotlin.test.assertSame
 
 class DeviceTest {
 
   @Test
-  fun `copying device wont have the same references`() {
+  fun `copying device keeps date reference and copies other mutable references`() {
     val device = Device()
     device.archs = arrayOf("archs1", "archs2")
     device.bootTime = Date()
@@ -23,7 +24,7 @@ class DeviceTest {
     assertNotNull(clone)
     assertNotSame(device, clone)
     assertNotSame(device.archs, clone.archs)
-    assertNotSame(device.bootTime, clone.bootTime)
+    assertSame(device.bootTime, clone.bootTime)
     assertNotSame(device.timezone, clone.timezone)
     assertNotSame(device.unknown, clone.unknown)
   }
diff --git a/sentry/src/test/java/io/sentry/protocol/SentryBaseEventSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/SentryBaseEventSerializationTest.kt
index 4cafb1ed8a8..35322d2659e 100644
--- a/sentry/src/test/java/io/sentry/protocol/SentryBaseEventSerializationTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/SentryBaseEventSerializationTest.kt
@@ -9,6 +9,7 @@ import io.sentry.SentryBaseEvent
 import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.vendor.gson.stream.JsonToken
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
 import org.junit.After
 import org.junit.Before
 import org.junit.Test
@@ -102,4 +103,26 @@ class SentryBaseEventSerializationTest {
 
     assertEquals(expectedJson, actualJson)
   }
+
+  @Test
+  fun `setTags copies source map`() {
+    val source = mutableMapOf("a" to "1")
+    val sut = Sut()
+
+    sut.tags = source
+    source["b"] = "2"
+
+    assertFalse(sut.tags!!.containsKey("b"))
+  }
+
+  @Test
+  fun `setExtras copies source map`() {
+    val source = mutableMapOf<String, Any>("a" to "1")
+    val sut = Sut()
+
+    sut.setExtras(source)
+    source["b"] = "2"
+
+    assertFalse(sut.extras!!.containsKey("b"))
+  }
 }

From 8c43a107a007ae5e2aea365bdf434318784049d7 Mon Sep 17 00:00:00 2001
From: adinauer <2542832+adinauer@users.noreply.github.com>
Date: Thu, 25 Jun 2026 14:21:16 +0000
Subject: [PATCH 240/391] release: 8.46.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 851fc3985e5..085cf8e35df 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.46.0
 
 ### Behavioral Changes
 
diff --git a/gradle.properties b/gradle.properties
index f83b851f8d9..804e4b58573 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.45.0
+versionName=8.46.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From d500866b45ecf8012bdd05876ab70b538a7d6371 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 25 Jun 2026 20:21:03 +0200
Subject: [PATCH 241/391] fix(replay): Fix network detail response body size
 being unknown for gzip-compressed responses (#5592)

* fix(replay): Derive response body size from peeked bytes when contentLength is unknown

For gzip-compressed responses, OkHttp strips the Content-Length header
during transparent decompression, so response.body.contentLength() returns
-1. This caused NetworkRequestData.responseBodySize to be unknown for
replay network details.

Add originalByteCount to NetworkBody, set it from the actual byte array
in NetworkBodyParser.fromBytes, and use it as a fallback in
NetworkDetailCaptureUtils when the passed bodySize is null or -1. This
piggybacks on the existing peekBody call with no additional I/O.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* changelog

* Changelog

* fix(replay): make NetworkBody 3-arg constructor package-private

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  4 ++
 .../io/sentry/util/network/NetworkBody.java   | 15 ++++-
 .../util/network/NetworkBodyParser.java       | 17 ++++--
 .../network/NetworkDetailCaptureUtils.java    |  8 ++-
 .../util/network/NetworkBodyParserTest.kt     | 21 +++++++
 .../network/NetworkDetailCaptureUtilsTest.kt  | 58 +++++++++++++++++++
 6 files changed, 117 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 085cf8e35df..4e8df66b782 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## 8.46.0
 
+### Fixes
+
+- Session Replay: Fix network detail response body size being unknown for gzip-compressed responses ([#5592](https://github.com/getsentry/sentry-java/pull/5592))
+
 ### Behavioral Changes
 
 - Collections returned by scope (e.g. `getBreadcrumbs`, `getTags`, `getAttachments`) are shared state and should not be mutated. ([#5541](https://github.com/getsentry/sentry-java/pull/5541))
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
index 5b4f6365ad4..bcea8cff6e7 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBody.java
@@ -16,15 +16,24 @@ public final class NetworkBody {
 
   private final @Nullable Object body;
   private final @Nullable List<NetworkBodyWarning> warnings;
+  private final long originalByteCount;
 
   public NetworkBody(final @Nullable Object body) {
-    this(body, null);
+    this(body, null, -1);
   }
 
   public NetworkBody(
       final @Nullable Object body, final @Nullable List<NetworkBodyWarning> warnings) {
+    this(body, warnings, -1);
+  }
+
+  NetworkBody(
+      final @Nullable Object body,
+      final @Nullable List<NetworkBodyWarning> warnings,
+      final long originalByteCount) {
     this.body = body;
     this.warnings = warnings;
+    this.originalByteCount = originalByteCount;
   }
 
   public @Nullable Object getBody() {
@@ -35,6 +44,10 @@ public NetworkBody(
     return warnings;
   }
 
+  long getOriginalByteCount() {
+    return originalByteCount;
+  }
+
   // Based on
   // https://github.com/getsentry/sentry/blob/ccb61aa9b0f33e1333830093a5ce3bd5db88ef33/static/app/utils/replays/replay.tsx#L5-L12
   public enum NetworkBodyWarning {
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java b/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
index 49325a99003..42df5ca35b9 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkBodyParser.java
@@ -45,24 +45,33 @@ private NetworkBodyParser() {}
       return null;
     }
 
+    final boolean isTruncated = bytes.length > maxSizeBytes;
+    final long originalByteCount = bytes.length;
+
     if (contentType != null && isBinaryContentType(contentType)) {
       // For binary content, return a description instead of the actual content
       return new NetworkBody(
-          "[Binary data, " + bytes.length + " bytes, type: " + contentType + "]");
+          "[Binary data, " + bytes.length + " bytes, type: " + contentType + "]",
+          null,
+          originalByteCount);
     }
 
     // Convert to string and parse
     try {
       final String effectiveCharset = charset != null ? charset : "UTF-8";
       final int size = Math.min(bytes.length, maxSizeBytes);
-      final boolean isPartial = bytes.length > maxSizeBytes;
       final String content = new String(bytes, 0, size, effectiveCharset);
-      return parse(content, contentType, isPartial, logger);
+      final NetworkBody parsed = parse(content, contentType, isTruncated, logger);
+      if (parsed == null) {
+        return null;
+      }
+      return new NetworkBody(parsed.getBody(), parsed.getWarnings(), originalByteCount);
     } catch (UnsupportedEncodingException e) {
       logger.log(SentryLevel.WARNING, "Failed to decode bytes: " + e.getMessage());
       return new NetworkBody(
           "[Failed to decode bytes, " + bytes.length + " bytes]",
-          Collections.singletonList(NetworkBody.NetworkBodyWarning.BODY_PARSE_ERROR));
+          Collections.singletonList(NetworkBody.NetworkBodyWarning.BODY_PARSE_ERROR),
+          originalByteCount);
     }
   }
 
diff --git a/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java b/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
index e0438c375b1..f5134693e00 100644
--- a/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
+++ b/sentry/src/main/java/io/sentry/util/network/NetworkDetailCaptureUtils.java
@@ -160,9 +160,15 @@ private static boolean shouldCaptureUrl(
       body = bodyExtractor.extract(httpObject);
     }
 
+    // When contentLength is unknown (-1), use the actual byte count from body extraction
+    Long effectiveBodySize = bodySize;
+    if ((bodySize == null || bodySize == -1L) && body != null && body.getOriginalByteCount() >= 0) {
+      effectiveBodySize = body.getOriginalByteCount();
+    }
+
     Map<String, String> headers =
         getCaptureHeaders(headerExtractor.extract(httpObject), allowedHeaders);
 
-    return new ReplayNetworkRequestOrResponse(bodySize, body, headers);
+    return new ReplayNetworkRequestOrResponse(effectiveBodySize, body, headers);
   }
 }
diff --git a/sentry/src/test/java/io/sentry/util/network/NetworkBodyParserTest.kt b/sentry/src/test/java/io/sentry/util/network/NetworkBodyParserTest.kt
index 3b1da25a0c2..04a19d47712 100644
--- a/sentry/src/test/java/io/sentry/util/network/NetworkBodyParserTest.kt
+++ b/sentry/src/test/java/io/sentry/util/network/NetworkBodyParserTest.kt
@@ -341,6 +341,27 @@ class NetworkBodyParserTest {
     val body = NetworkBodyParser.fromBytes(bytes, "image/png", null, bytes.size, logger)
     assertNotNull(body)
     assertEquals("[Binary data, 100 bytes, type: image/png]", body.body)
+    assertEquals(100, body.originalByteCount)
+  }
+
+  @Test
+  fun `originalByteCount is set when body fits within limit`() {
+    val logger = mock<ILogger>()
+    val bytes = """{"key":"value"}""".toByteArray()
+
+    val body = NetworkBodyParser.fromBytes(bytes, "application/json", null, bytes.size, logger)
+    assertNotNull(body)
+    assertEquals(bytes.size.toLong(), body.originalByteCount)
+  }
+
+  @Test
+  fun `originalByteCount is set to capped size when body is truncated`() {
+    val logger = mock<ILogger>()
+    val bytes = """{"key":"value"}""".toByteArray()
+
+    val body = NetworkBodyParser.fromBytes(bytes, "application/json", null, bytes.size - 1, logger)
+    assertNotNull(body)
+    assertEquals(bytes.size.toLong(), body.originalByteCount)
   }
 
   @Test
diff --git a/sentry/src/test/java/io/sentry/util/network/NetworkDetailCaptureUtilsTest.kt b/sentry/src/test/java/io/sentry/util/network/NetworkDetailCaptureUtilsTest.kt
index cf4ec4828ff..25b142af7e9 100644
--- a/sentry/src/test/java/io/sentry/util/network/NetworkDetailCaptureUtilsTest.kt
+++ b/sentry/src/test/java/io/sentry/util/network/NetworkDetailCaptureUtilsTest.kt
@@ -1,12 +1,70 @@
 package io.sentry.util.network
 
+import io.sentry.ILogger
 import java.util.LinkedHashMap
 import kotlin.test.assertEquals
+import kotlin.test.assertNull
 import kotlin.test.assertTrue
 import org.junit.Test
+import org.mockito.kotlin.mock
 
 class NetworkDetailCaptureUtilsTest {
 
+  @Test
+  fun `createResponse uses originalByteCount when bodySize is unknown`() {
+    val logger = mock<ILogger>()
+    val jsonBytes = """{"key":"value"}""".toByteArray()
+
+    val result =
+      NetworkDetailCaptureUtils.createResponse(
+        jsonBytes,
+        -1L,
+        true,
+        { bytes ->
+          NetworkBodyParser.fromBytes(bytes, "application/json", null, bytes.size, logger)
+        },
+        emptyList(),
+        { emptyMap() },
+      )
+
+    assertEquals(jsonBytes.size.toLong(), result.size)
+  }
+
+  @Test
+  fun `createResponse keeps explicit bodySize when available`() {
+    val logger = mock<ILogger>()
+    val jsonBytes = """{"key":"value"}""".toByteArray()
+
+    val result =
+      NetworkDetailCaptureUtils.createResponse(
+        jsonBytes,
+        42L,
+        true,
+        { bytes ->
+          NetworkBodyParser.fromBytes(bytes, "application/json", null, bytes.size, logger)
+        },
+        emptyList(),
+        { emptyMap() },
+      )
+
+    assertEquals(42L, result.size)
+  }
+
+  @Test
+  fun `createResponse keeps null bodySize when body capture is off`() {
+    val result =
+      NetworkDetailCaptureUtils.createResponse(
+        "unused",
+        null,
+        false,
+        { null },
+        emptyList(),
+        { emptyMap() },
+      )
+
+    assertNull(result.size)
+  }
+
   @Test
   fun `getCaptureHeaders should match headers case-insensitively`() {
     // Setup: allHeaders with mixed case keys

From b3299ecb0a4145c3409adfb2ad70c8c444741626 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 26 Jun 2026 06:47:34 +0000
Subject: [PATCH 242/391] chore(deps): bump the github-actions group across 1
 directory with 6 updates (#5647)

Bumps the github-actions group with 6 updates in the / directory:

| Package | From | To |
| --- | --- | --- |
| [actions/setup-java](https://github.com/actions/setup-java) | `5.3.0` | `5.4.0` |
| [gradle/actions/setup-gradle](https://github.com/gradle/actions) | `6.1.0` | `6.2.0` |
| [actions/cache](https://github.com/actions/cache) | `5.0.5` | `6.0.0` |
| [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) | `2.26.10` | `2.26.12` |
| [getsentry/craft](https://github.com/getsentry/craft) | `2.26.10` | `2.26.12` |
| [actions/setup-python](https://github.com/actions/setup-python) | `6.2.0` | `6.3.0` |



Updates `actions/setup-java` from 5.3.0 to 5.4.0
- [Release notes](https://github.com/actions/setup-java/releases)
- [Commits](https://github.com/actions/setup-java/compare/ad2b38190b15e4d6bdf0c97fb4fca8412226d287...1bcf9fb12cf4aa7d266a90ae39939e61372fe520)

Updates `gradle/actions/setup-gradle` from 6.1.0 to 6.2.0
- [Release notes](https://github.com/gradle/actions/releases)
- [Commits](https://github.com/gradle/actions/compare/50e97c2cd7a37755bbfafc9c5b7cafaece252f6e...3f131e8634966bd73d06cc69884922b02e6faf92)

Updates `actions/cache` from 5.0.5 to 6.0.0
- [Release notes](https://github.com/actions/cache/releases)
- [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md)
- [Commits](https://github.com/actions/cache/compare/27d5ce7f107fe9357f9df03efb73ab90386fccae...2c8a9bd7457de244a408f35966fab2fb45fda9c8)

Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.26.10 to 2.26.12
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/acdb88019720182caf57293360d7cdc8db9e75ac...9312e4dfc82e545ef0cad911c23f430fe5f52673)

Updates `getsentry/craft` from 2.26.10 to 2.26.12
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/acdb88019720182caf57293360d7cdc8db9e75ac...9312e4dfc82e545ef0cad911c23f430fe5f52673)

Updates `actions/setup-python` from 6.2.0 to 6.3.0
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/a309ff8b426b58ec0e2a45f0f869d46889d02405...ece7cb06caefa5fff74198d8649806c4678c61a1)

---
updated-dependencies:
- dependency-name: actions/setup-java
  dependency-version: 5.4.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: gradle/actions/setup-gradle
  dependency-version: 6.2.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: actions/cache
  dependency-version: 6.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.26.12
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: getsentry/craft
  dependency-version: 2.26.12
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: actions/setup-python
  dependency-version: 6.3.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    |  6 +++---
 .github/workflows/build.yml                         |  6 +++---
 .github/workflows/changelog-preview.yml             |  2 +-
 .github/workflows/codeql-analysis.yml               |  4 ++--
 .github/workflows/enforce-license-compliance.yml    |  4 ++--
 .github/workflows/format-code.yml                   |  4 ++--
 .github/workflows/generate-javadocs.yml             |  4 ++--
 .github/workflows/integration-tests-benchmarks.yml  | 10 +++++-----
 .github/workflows/integration-tests-size.yml        |  6 +++---
 .github/workflows/integration-tests-ui-critical.yml |  6 +++---
 .github/workflows/integration-tests-ui.yml          |  4 ++--
 .github/workflows/release-build.yml                 |  4 ++--
 .github/workflows/release.yml                       |  2 +-
 .github/workflows/spring-boot-2-matrix.yml          |  8 ++++----
 .github/workflows/spring-boot-3-matrix.yml          |  8 ++++----
 .github/workflows/spring-boot-4-matrix.yml          |  8 ++++----
 .github/workflows/system-tests-backend.yml          |  6 +++---
 17 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 8ddb961ec96..d196d595d73 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -33,13 +33,13 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
@@ -50,7 +50,7 @@ jobs:
           sudo udevadm trigger --name-match=kvm
 
       - name: AVD cache
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
+        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
         id: avd-cache
         with:
           path: |
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6cba7e07e0a..57106c8e05a 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -25,20 +25,20 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
+        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index d814ca72002..3e510787ce2 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@acdb88019720182caf57293360d7cdc8db9e75ac # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@9312e4dfc82e545ef0cad911c23f430fe5f52673 # v2
     secrets: inherit
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index ccc9cc04a85..c3cad17b1a9 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -25,13 +25,13 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index 38680fe0a23..33a0cc237fc 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -11,10 +11,10 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
 
       - name: Set up Java
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index 2892df16701..3fc47aa0f6b 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -13,13 +13,13 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index fabd36736aa..be15b66d370 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -14,13 +14,13 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
 
       - name: Generate Aggregate Javadocs
         run: |
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 45b063705dc..fa025030e8a 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -32,13 +32,13 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
@@ -82,17 +82,17 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
-      - uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
+      - uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
         id: app-plain-cache
         with:
           path: sentry-android-integration-tests/test-app-plain/build/outputs/apk/release/test-app-plain-release.apk
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index 5c212d5895a..d67237d7089 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -23,20 +23,20 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Setup Java Version
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: "temurin"
           java-version: "17"
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
+        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 7d0b74b4329..bd4a9058ddc 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -30,13 +30,13 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Set up Java 17
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
@@ -86,7 +86,7 @@ jobs:
           sudo udevadm trigger --name-match=kvm
 
       - name: AVD cache
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
+        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
         id: avd-cache
         with:
           path: |
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index e271227b97e..9404975a1fc 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -27,13 +27,13 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 050782006f0..eac4a94966c 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -20,13 +20,13 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
 
       - name: Build artifacts
         run: make publish
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index dd266d948c2..807236d4ed2 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@acdb88019720182caf57293360d7cdc8db9e75ac # v2
+        uses: getsentry/craft@9312e4dfc82e545ef0cad911c23f430fe5f52673 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 6e0b1366c9f..cf69a869def 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -35,7 +35,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6
         with:
           python-version: '3.10.5'
 
@@ -45,20 +45,20 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
+        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 00e93f5442b..2a94987549c 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -35,7 +35,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6
         with:
           python-version: '3.10.5'
 
@@ -45,20 +45,20 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
+        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 450dbd8c98d..b5516e17453 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -35,7 +35,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6
         with:
           python-version: '3.10.5'
 
@@ -45,20 +45,20 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@27d5ce7f107fe9357f9df03efb73ab90386fccae # v5
+        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 67f81f2fb64..ed6b5eab5f7 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -102,7 +102,7 @@ jobs:
         with:
           submodules: 'recursive'
 
-      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6
         with:
           python-version: '3.10.5'
 
@@ -112,13 +112,13 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5
+        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@50e97c2cd7a37755bbfafc9c5b7cafaece252f6e # v6.1.0
+        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 

From c4538565b7fe7d1d50dddb46c44b2b93129d74ee Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 26 Jun 2026 10:21:49 +0200
Subject: [PATCH 243/391] test(replay): ignore flaky ComposeMaskingOptionsTest
 unmask test (#5648)

* test(replay): ignore flaky ComposeMaskingOptionsTest unmask test

Co-Authored-By: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>

* Format code

---------

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 .../android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
index fe3fbc1ba67..baf0a32a415 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
@@ -44,6 +44,7 @@ import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.GenericViewHiera
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.ImageViewHierarchyNode
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.TextViewHierarchyNode
 import java.io.File
+import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -219,6 +220,9 @@ class ComposeMaskingOptionsTest {
   }
 
   @Test
+  @Ignore(
+    "Flaky: Robolectric intermittently reports zero bounds for nodes, causing isVisible=false and making the assertion non-deterministic"
+  )
   fun `when sentry-unmask modifier is set unmasks the node`() {
     ComposeMaskingOptionsActivity.textModifierApplier = { Modifier.sentryReplayUnmask() }
     val activity = buildActivity(ComposeMaskingOptionsActivity::class.java).setup()

From d8b6ce11cabd05be9a3f03a1d20fe247956d091d Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 26 Jun 2026 10:52:36 +0200
Subject: [PATCH 244/391] perf(android): Hit-test gestures without
 getLocationOnScreen (#5595)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* perf(android): Hit-test gestures without getLocationOnScreen (JAVA-534)

ViewUtils.findTarget called View.getLocationOnScreen for every visited
view, and that walks from the view up to the root each time, making the
traversal O(N*depth) per tap and scroll start.

Instead, map the touch point down into each child's local coordinate
space as we descend the tree — the same way ViewGroup dispatches touch
events — so each view costs O(1) and the whole traversal is O(N). The
locators still receive the original decor-view-relative coordinates,
since the Compose locator hit-tests against window coordinates.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* Update changelog

* test(android): Cover scroll and child matrix in findTarget hit-testing (JAVA-534)

The existing test only exercised the left/top offset path of mapToChild.
Add cases for a scrolled parent and a non-identity child matrix so the
other two coordinate-mapping branches are covered, and switch the class
to Robolectric so the real Matrix math runs.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Move changelog entry to Unreleased as a performance improvement

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   6 ++
 .../core/internal/gestures/ViewUtils.java     |  88 +++++++++++----
 .../core/internal/gestures/ViewHelpers.kt     |  29 ++---
 .../core/internal/gestures/ViewUtilsTest.kt   | 100 +++++++++++++++++-
 .../gestures/ComposeGestureTargetLocator.kt   |   9 +-
 5 files changed, 184 insertions(+), 48 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4e8df66b782..eaec96a2e0a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Performance
+
+- Speed up touch gesture target detection on deeply nested view hierarchies by hit-testing in local coordinates instead of calling `getLocationOnScreen` per view ([#5595](https://github.com/getsentry/sentry-java/pull/5595))
+
 ## 8.46.0
 
 ### Fixes
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/ViewUtils.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/ViewUtils.java
index 501a05a5007..6f52612e50d 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/ViewUtils.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/ViewUtils.java
@@ -1,13 +1,14 @@
 package io.sentry.android.core.internal.gestures;
 
 import android.content.res.Resources;
+import android.graphics.Matrix;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import io.sentry.android.core.SentryAndroidOptions;
 import io.sentry.internal.gestures.GestureTargetLocator;
 import io.sentry.internal.gestures.UiElement;
-import java.util.LinkedList;
+import java.util.ArrayDeque;
 import java.util.List;
 import java.util.Queue;
 import org.jetbrains.annotations.ApiStatus;
@@ -17,30 +18,53 @@
 @ApiStatus.Internal
 public final class ViewUtils {
 
-  private static final int[] coordinates = new int[2];
-
   /**
-   * Verifies if the given touch coordinates are within the bounds of the given view.
+   * Verifies if the given touch coordinates, expressed in the view's own local coordinate space,
+   * are within the bounds of the given view.
    *
    * @param view the view to check if the touch coordinates are within its bounds
-   * @param x - the x coordinate of a {@link MotionEvent}
-   * @param y - the y coordinate of {@link MotionEvent}
+   * @param localX - the x coordinate of the touch, relative to the view's top-left corner
+   * @param localY - the y coordinate of the touch, relative to the view's top-left corner
    * @return true if the touch coordinates are within the bounds of the view, false otherwise
    */
   private static boolean touchWithinBounds(
-      final @Nullable View view, final float x, final float y) {
+      final @Nullable View view, final float localX, final float localY) {
     if (view == null) {
       return false;
     }
 
-    view.getLocationOnScreen(coordinates);
-    int vx = coordinates[0];
-    int vy = coordinates[1];
+    final int w = view.getWidth();
+    final int h = view.getHeight();
 
-    int w = view.getWidth();
-    int h = view.getHeight();
+    return !(localX < 0 || localX > w || localY < 0 || localY > h);
+  }
 
-    return !(x < vx || x > vx + w || y < vy || y > vy + h);
+  /**
+   * Maps a touch point expressed in the parent's local coordinate space into the child's local
+   * coordinate space. This mirrors how {@link ViewGroup} dispatches touch events to its children
+   * and lets us hit-test the whole tree with a single downward traversal, instead of calling {@link
+   * View#getLocationOnScreen(int[])} (which walks up to the root) for every view.
+   */
+  private static @NotNull ViewWithLocation mapToChild(
+      final @NotNull View child,
+      final float parentX,
+      final float parentY,
+      final int parentScrollX,
+      final int parentScrollY) {
+    float childX = parentX + parentScrollX - child.getLeft();
+    float childY = parentY + parentScrollY - child.getTop();
+
+    final @Nullable Matrix matrix = child.getMatrix();
+    if (matrix != null && !matrix.isIdentity()) {
+      final Matrix inverse = new Matrix();
+      if (matrix.invert(inverse)) {
+        final float[] point = {childX, childY};
+        inverse.mapPoints(point);
+        childX = point[0];
+        childY = point[1];
+      }
+    }
+    return new ViewWithLocation(child, childX, childY);
   }
 
   /**
@@ -48,8 +72,8 @@ private static boolean touchWithinBounds(
    * given {@code viewTargetSelector}.
    *
    * @param decorView - the root view of this window
-   * @param x - the x coordinate of a {@link MotionEvent}
-   * @param y - the y coordinate of {@link MotionEvent}
+   * @param x - the x coordinate of a {@link MotionEvent}, relative to the decor view
+   * @param y - the y coordinate of {@link MotionEvent}, relative to the decor view
    * @param targetType - the type of target to find
    * @return the {@link View} that contains the touch coordinates and complements the {@code
    *     viewTargetSelector}
@@ -62,25 +86,35 @@ private static boolean touchWithinBounds(
       final UiElement.Type targetType) {
 
     final List<GestureTargetLocator> locators = options.getGestureTargetLocators();
-    final Queue<View> queue = new LinkedList<>();
-    queue.add(decorView);
+    final Queue<ViewWithLocation> queue = new ArrayDeque<>();
+    // The touch coordinates from the MotionEvent are already relative to the decor view, i.e. in
+    // its local coordinate space.
+    queue.add(new ViewWithLocation(decorView, x, y));
 
     @Nullable UiElement target = null;
-    while (queue.size() > 0) {
-      final View view = queue.poll();
+    while (!queue.isEmpty()) {
+      final ViewWithLocation current = queue.poll();
+      final View view = current.view;
 
-      if (!touchWithinBounds(view, x, y)) {
+      if (!touchWithinBounds(view, current.x, current.y)) {
         // if the touch is not hitting the view, skip traversal of its children
         continue;
       }
 
       if (view instanceof ViewGroup) {
         final ViewGroup viewGroup = (ViewGroup) view;
+        final int scrollX = viewGroup.getScrollX();
+        final int scrollY = viewGroup.getScrollY();
         for (int i = 0; i < viewGroup.getChildCount(); i++) {
-          queue.add(viewGroup.getChildAt(i));
+          final @Nullable View child = viewGroup.getChildAt(i);
+          if (child != null) {
+            queue.add(mapToChild(child, current.x, current.y, scrollX, scrollY));
+          }
         }
       }
 
+      // Locators receive the original decor-view-relative coordinates, as the Compose locator
+      // hit-tests against window coordinates.
       for (int i = 0; i < locators.size(); i++) {
         final GestureTargetLocator locator = locators.get(i);
         final @Nullable UiElement newTarget = locator.locate(view, x, y, targetType);
@@ -96,6 +130,18 @@ private static boolean touchWithinBounds(
     return target;
   }
 
+  private static final class ViewWithLocation {
+    final @NotNull View view;
+    final float x;
+    final float y;
+
+    ViewWithLocation(final @NotNull View view, final float x, final float y) {
+      this.view = view;
+      this.x = x;
+      this.y = y;
+    }
+  }
+
   /**
    * Retrieves the human-readable view id based on {@code view.getContext().getResources()}, falls
    * back to a hexadecimal id representation in case the view id is not available in the resources.
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewHelpers.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewHelpers.kt
index 1a4f28bbe35..15123ce0a31 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewHelpers.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewHelpers.kt
@@ -5,9 +5,6 @@ import android.content.res.Resources
 import android.view.MotionEvent
 import android.view.View
 import android.view.Window
-import kotlin.math.abs
-import org.mockito.kotlin.any
-import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.whenever
@@ -35,31 +32,17 @@ internal inline fun <reified T : View> mockView(
   context: Context? = null,
   finalize: (T) -> Unit = {},
 ): T {
-  val coordinates = IntArray(2)
-  if (!touchWithinBounds) {
-    coordinates[0] = (event.x).toInt() + 10
-    coordinates[1] = (event.y).toInt() + 10
-  } else {
-    coordinates[0] = (event.x).toInt() - 10
-    coordinates[1] = (event.y).toInt() - 10
-  }
+  // The decor-view-relative touch point used in these tests is (0, 0), and child views are mocked
+  // at offset (0, 0), so the point reaches every view unchanged. A view therefore contains the
+  // touch iff its width/height are non-negative; a negative size marks the touch as outside.
+  val size = if (touchWithinBounds) 10 else -1
   val mockView: T = mock {
     whenever(it.id).thenReturn(id)
     whenever(it.context).thenReturn(context)
     whenever(it.isClickable).thenReturn(clickable)
     whenever(it.visibility).thenReturn(if (visible) View.VISIBLE else View.GONE)
-
-    whenever(it.getLocationOnScreen(any())).doAnswer {
-      val array = it.arguments[0] as IntArray
-      array[0] = coordinates[0]
-      array[1] = coordinates[1]
-      null
-    }
-
-    val diffPosX = abs(event.x - coordinates[0]).toInt()
-    val diffPosY = abs(event.y - coordinates[1]).toInt()
-    whenever(it.width).thenReturn(diffPosX + 10)
-    whenever(it.height).thenReturn(diffPosY + 10)
+    whenever(it.width).thenReturn(size)
+    whenever(it.height).thenReturn(size)
 
     finalize(this.mock)
   }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewUtilsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewUtilsTest.kt
index 77a38e6ccc1..10064b1cd74 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewUtilsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewUtilsTest.kt
@@ -2,10 +2,19 @@ package io.sentry.android.core.internal.gestures
 
 import android.content.Context
 import android.content.res.Resources
+import android.graphics.Matrix
 import android.view.View
+import android.view.ViewGroup
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.android.core.SentryAndroidOptions
+import io.sentry.internal.gestures.UiElement
+import io.sentry.util.LazyEvaluator
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import org.junit.runner.RunWith
 import org.mockito.kotlin.any
 import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.doThrow
@@ -14,12 +23,13 @@ import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 
+@RunWith(AndroidJUnit4::class)
 class ViewUtilsTest {
   @Test
   fun `getResourceId returns resourceId when available`() {
     val view =
       mock<View> {
-        whenever(it.id).doReturn(View.generateViewId())
+        whenever(it.id).doReturn(0x7f010001)
 
         val context = mock<Context>()
         val resources = mock<Resources>()
@@ -80,6 +90,94 @@ class ViewUtilsTest {
     verify(context, never()).resources
   }
 
+  @Test
+  fun `findTarget hit-tests children in their own local coordinate space`() {
+    val child = clickableChild()
+    val decorView =
+      mock<ViewGroup> {
+        whenever(it.width).thenReturn(1000)
+        whenever(it.height).thenReturn(1000)
+        whenever(it.childCount).thenReturn(1)
+        whenever(it.getChildAt(0)).thenReturn(child)
+      }
+    val options = optionsWithViewLocator()
+
+    // (120, 220) maps to (20, 20) in the child's space -> inside its 50x50 bounds.
+    assertNotNull(ViewUtils.findTarget(options, decorView, 120f, 220f, UiElement.Type.CLICKABLE))
+
+    // (90, 220) maps to (-10, 20) in the child's space -> outside, despite being inside the decor.
+    assertNull(ViewUtils.findTarget(options, decorView, 90f, 220f, UiElement.Type.CLICKABLE))
+  }
+
+  @Test
+  fun `findTarget accounts for parent scroll when mapping into a child`() {
+    val child = clickableChild()
+    val decorView =
+      mock<ViewGroup> {
+        whenever(it.width).thenReturn(1000)
+        whenever(it.height).thenReturn(1000)
+        whenever(it.scrollX).thenReturn(30)
+        whenever(it.scrollY).thenReturn(40)
+        whenever(it.childCount).thenReturn(1)
+        whenever(it.getChildAt(0)).thenReturn(child)
+      }
+    val options = optionsWithViewLocator()
+
+    // With scroll (30, 40), (90, 180) maps to (90 + 30 - 100, 180 + 40 - 200) = (20, 20) -> inside.
+    assertNotNull(ViewUtils.findTarget(options, decorView, 90f, 180f, UiElement.Type.CLICKABLE))
+
+    // The same point without accounting for scroll would map to (-10, -20) -> outside the child.
+    assertNull(ViewUtils.findTarget(options, decorView, 50f, 140f, UiElement.Type.CLICKABLE))
+  }
+
+  @Test
+  fun `findTarget applies the inverse of a non-identity child matrix`() {
+    // The child is visually translated by (40, 40) within its parent, so a parent-space point is
+    // mapped back by (-40, -40) to reach the child's own coordinate space.
+    val matrix = Matrix().apply { setTranslate(40f, 40f) }
+    val child = clickableChild { whenever(it.matrix).thenReturn(matrix) }
+    val decorView =
+      mock<ViewGroup> {
+        whenever(it.width).thenReturn(1000)
+        whenever(it.height).thenReturn(1000)
+        whenever(it.childCount).thenReturn(1)
+        whenever(it.getChildAt(0)).thenReturn(child)
+      }
+    val options = optionsWithViewLocator()
+
+    // (180, 280) lands at (80, 80) before the matrix (outside 50x50), but the inverse pulls it to
+    // (40, 40) -> inside.
+    assertNotNull(ViewUtils.findTarget(options, decorView, 180f, 280f, UiElement.Type.CLICKABLE))
+
+    // (130, 230) lands at (30, 30) before the matrix (inside), but the inverse pushes it to
+    // (-10, -10) -> outside.
+    assertNull(ViewUtils.findTarget(options, decorView, 130f, 230f, UiElement.Type.CLICKABLE))
+  }
+
+  // A clickable child positioned at (100, 200) within its parent, 50x50 in size.
+  private fun clickableChild(finalize: (View) -> Unit = {}): View {
+    val context = mock<Context>()
+    val resources = mock<Resources>()
+    whenever(context.resources).thenReturn(resources)
+    whenever(resources.getResourceEntryName(any())).thenReturn("child")
+    return mock {
+      whenever(it.id).thenReturn(0x7f010001)
+      whenever(it.context).thenReturn(context)
+      whenever(it.isClickable).thenReturn(true)
+      whenever(it.visibility).thenReturn(View.VISIBLE)
+      whenever(it.left).thenReturn(100)
+      whenever(it.top).thenReturn(200)
+      whenever(it.width).thenReturn(50)
+      whenever(it.height).thenReturn(50)
+      finalize(this.mock)
+    }
+  }
+
+  private fun optionsWithViewLocator(): SentryAndroidOptions =
+    SentryAndroidOptions().apply {
+      gestureTargetLocators = listOf(AndroidViewGestureTargetLocator(LazyEvaluator { true }))
+    }
+
   @Test
   fun `getResourceIdWithFallback falls back to hexadecimal id when resource not found`() {
     val view =
diff --git a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocator.kt b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocator.kt
index 54deb774c53..47dda6eda9c 100644
--- a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocator.kt
+++ b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/gestures/ComposeGestureTargetLocator.kt
@@ -15,7 +15,7 @@ import io.sentry.compose.boundsInWindow
 import io.sentry.internal.gestures.GestureTargetLocator
 import io.sentry.internal.gestures.UiElement
 import io.sentry.util.AutoClosableReentrantLock
-import java.util.LinkedList
+import java.util.ArrayDeque
 import java.util.Queue
 
 @OptIn(InternalComposeUiApi::class)
@@ -45,7 +45,7 @@ public class ComposeGestureTargetLocator(private val logger: ILogger) : GestureT
     val rootLayoutNode = root.root
 
     // Pair<Node, ParentTag>
-    val queue: Queue<Pair<LayoutNode, String?>> = LinkedList()
+    val queue: Queue<Pair<LayoutNode, String?>> = ArrayDeque()
     queue.add(Pair(rootLayoutNode, null))
 
     // the final tag to return, only relevant for clicks
@@ -92,7 +92,10 @@ public class ComposeGestureTargetLocator(private val logger: ILogger) : GestureT
             }
           }
         }
-        queue.addAll(node.zSortedChildren.asMutableList().map { Pair(it, tag) })
+        val children = node.zSortedChildren.asMutableList()
+        for (index in children.indices) {
+          queue.add(Pair(children[index], tag))
+        }
       }
     }
 

From d28345f99bf478304e7bfab7beda00c46b01ece0 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Mon, 29 Jun 2026 10:18:37 +0200
Subject: [PATCH 245/391] fix(core): Guard clearSession with session lock to
 prevent NPE (#5657)

* fix(core): Guard clearSession with session lock to prevent NPE

clearSession() reset the session field without acquiring sessionLock,
unlike the other session mutators (startSession, endSession,
withSession). This allowed it to null out the session between a
null-check and a dereference (e.g. session.clone()) in those locked
methods, leading to a NullPointerException. Acquire sessionLock so all
session mutations are mutually exclusive.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* changelog

* changelog

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                              | 4 ++++
 sentry/src/main/java/io/sentry/Scope.java | 4 +++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eaec96a2e0a..dbb532e1f82 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+
+- Fix potential NPE within `Scope.endSession()` ([#5657](https://github.com/getsentry/sentry-java/pull/5657))
+
 ### Performance
 
 - Speed up touch gesture target detection on deeply nested view hierarchies by hit-testing in local coordinates instead of calling `getLocationOnScreen` per view ([#5595](https://github.com/getsentry/sentry-java/pull/5595))
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index 9e8d3ee554e..282fc4df67f 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -1147,7 +1147,9 @@ public SentryOptions getOptions() {
   @ApiStatus.Internal
   @Override
   public void clearSession() {
-    session = null;
+    try (final @NotNull ISentryLifecycleToken ignored = sessionLock.acquire()) {
+      session = null;
+    }
   }
 
   @ApiStatus.Internal

From 151b497f664e05aed370dcab83278ba3c68ee826 Mon Sep 17 00:00:00 2001
From: XYZboom <58654313+XYZboom@users.noreply.github.com>
Date: Mon, 29 Jun 2026 16:52:49 +0800
Subject: [PATCH 246/391] Add @Throws on SentryOkHttpInterceptor::intercept.
 (#5654)

Fixes #5653
---
 CHANGELOG.md                                                  | 4 ++++
 .../src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt | 1 +
 2 files changed, 5 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dbb532e1f82..4a37500b9a1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Behavioral Changes
+
+- `SentryOkHttpInterceptor::intercept` now throws `IOException`. This is a source-only and Java-only breaking change ([#5654](https://github.com/getsentry/sentry-java/pull/5654))
+
 ### Fixes
 
 - Fix potential NPE within `Scope.endSession()` ([#5657](https://github.com/getsentry/sentry-java/pull/5657))
diff --git a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
index ea8fdb44159..7031be3b0b3 100644
--- a/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
+++ b/sentry-okhttp/src/main/java/io/sentry/okhttp/SentryOkHttpInterceptor.kt
@@ -77,6 +77,7 @@ public open class SentryOkHttpInterceptor(
   }
 
   @Suppress("LongMethod")
+  @Throws(IOException::class)
   override fun intercept(chain: Interceptor.Chain): Response {
     var request = chain.request()
 

From 012eaebafc1507c0a4767236b7acc5c26fca1988 Mon Sep 17 00:00:00 2001
From: Chris Aigner <25478494+christophaigner@users.noreply.github.com>
Date: Mon, 29 Jun 2026 20:55:43 +0200
Subject: [PATCH 247/391] docs: Add AI Use section to CONTRIBUTING.md (#5659)

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
---
 CONTRIBUTING.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7eb38413d64..f4354c72a89 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -68,3 +68,8 @@ issue without a closing keyword is not enough.
 
 Build and tests are automatically run against branches and pull requests
 via GH Actions.
+
+
+# AI Use
+
+You are welcome to use whatever tools you prefer for making a contribution. However, any changes you propose have to be reviewed and tested by you, a human, first, before you submit a pull request with them for the Sentry team to review. If we feel like that did not happen, we will close the PR outright. For example, we will not review visibly AI-generated PRs from an agent instructed to look for and "fix" open issues in the repo. This aligns with our SDK principle: [every line has an owner](https://develop.sentry.dev/sdk/getting-started/principles/#every-line-has-an-owner).

From 8fe8bad58f1cfd746f853286f0f241a3f2c5b3fb Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 30 Jun 2026 11:20:16 +0200
Subject: [PATCH 248/391] perf: Reduce reflection cost during SDK init (Init
 Reflection stack) (#5634)

* collection: Reduce reflection cost during SDK init

* perf(core): [Init Reflection 1] Probe class availability without initializing (#5635)

* perf(core): Probe class availability without initializing the class

LoadClass.loadClass used Class.forName(name) which initializes the
class. Used purely for availability probing during init, this eagerly
runs unrelated static initializers (e.g. Compose's Owner, the fragment
integration). Use Class.forName(name, false, classLoader) so the class
is only initialized lazily on first real use.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* changelog: move init reflection entries to Performance

* perf(core): Limit no-init class probing to isClassAvailable

The previous change made loadClass itself skip class initialization,
which affected callers that load a class to actually use it (NDK
integration, OTEL span factory and scopes storage). Restore loadClass
to its initializing behavior and confine the non-initializing probe to
isClassAvailable, which is only ever used for classpath availability
checks. This keeps SDK init cheap while leaving real-use callers
unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../main/java/io/sentry/util/LoadClass.java   | 34 ++++++++-
 .../test/java/io/sentry/util/LoadClassTest.kt | 70 +++++++++++++++++++
 3 files changed, 102 insertions(+), 3 deletions(-)
 create mode 100644 sentry/src/test/java/io/sentry/util/LoadClassTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4a37500b9a1..dce1fd22d22 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@
 ### Performance
 
 - Speed up touch gesture target detection on deeply nested view hierarchies by hit-testing in local coordinates instead of calling `getLocationOnScreen` per view ([#5595](https://github.com/getsentry/sentry-java/pull/5595))
+- Probe class availability without initializing the class during SDK init ([#5635](https://github.com/getsentry/sentry-java/pull/5635))
 
 ## 8.46.0
 
diff --git a/sentry/src/main/java/io/sentry/util/LoadClass.java b/sentry/src/main/java/io/sentry/util/LoadClass.java
index 1946ce8381f..2c39cace39b 100644
--- a/sentry/src/main/java/io/sentry/util/LoadClass.java
+++ b/sentry/src/main/java/io/sentry/util/LoadClass.java
@@ -12,15 +12,23 @@
 public class LoadClass {
 
   /**
-   * Try to load a class via reflection
+   * Loads and initializes a class via reflection. Use this when you intend to actually use the
+   * class (e.g. instantiate it or invoke its methods). The returned class is fully initialized, so
+   * its static initializers run. To merely check whether a class is on the classpath, use {@link
+   * #isClassAvailable} instead, which avoids running those initializers.
    *
    * @param clazz the full class name
    * @param logger an instance of ILogger
    * @return a Class&lt;?&gt; if it's available, or null
    */
   public @Nullable Class<?> loadClass(final @NotNull String clazz, final @Nullable ILogger logger) {
+    return loadClass(clazz, logger, true);
+  }
+
+  private @Nullable Class<?> loadClass(
+      final @NotNull String clazz, final @Nullable ILogger logger, final boolean initialize) {
     try {
-      return Class.forName(clazz);
+      return Class.forName(clazz, initialize, LoadClass.class.getClassLoader());
     } catch (ClassNotFoundException e) {
       if (logger != null) {
         logger.log(SentryLevel.INFO, "Class not available: " + clazz);
@@ -37,8 +45,19 @@ public class LoadClass {
     return null;
   }
 
+  /**
+   * Probes whether a class is on the classpath without initializing it. Use this for availability
+   * checks (e.g. deciding whether to register an integration); the class is not initialized, so its
+   * static initializers do not run until something actually uses it. This keeps SDK init cheap by
+   * not triggering unrelated initializers. If you need to use the class, use {@link #loadClass}
+   * instead.
+   *
+   * @param clazz the full class name
+   * @param logger an instance of ILogger
+   * @return true if the class is on the classpath
+   */
   public boolean isClassAvailable(final @NotNull String clazz, final @Nullable ILogger logger) {
-    return loadClass(clazz, logger) != null;
+    return loadClass(clazz, logger, false) != null;
   }
 
   public boolean isClassAvailable(
@@ -46,6 +65,15 @@ public boolean isClassAvailable(
     return isClassAvailable(clazz, options != null ? options.getLogger() : null);
   }
 
+  /**
+   * Like {@link #isClassAvailable}, but defers the (non-initializing) availability check until the
+   * result is first read. Use this when the check itself should not run during SDK init but only
+   * later, on first access.
+   *
+   * @param clazz the full class name
+   * @param logger an instance of ILogger
+   * @return a lazily-evaluated availability check
+   */
   public LazyEvaluator<Boolean> isClassAvailableLazy(
       final @NotNull String clazz, final @Nullable ILogger logger) {
     return new LazyEvaluator<>(() -> isClassAvailable(clazz, logger));
diff --git a/sentry/src/test/java/io/sentry/util/LoadClassTest.kt b/sentry/src/test/java/io/sentry/util/LoadClassTest.kt
new file mode 100644
index 00000000000..7a8bc802049
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/util/LoadClassTest.kt
@@ -0,0 +1,70 @@
+package io.sentry.util
+
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class LoadClassTest {
+  @Test
+  fun `loadClass returns the class when it is available`() {
+    assertNotNull(LoadClass().loadClass("io.sentry.SentryEvent", null))
+  }
+
+  @Test
+  fun `loadClass returns null when the class is not available`() {
+    assertNull(LoadClass().loadClass("io.sentry.ThisClassDoesNotExist", null))
+  }
+
+  @Test
+  fun `isClassAvailable reflects whether the class is on the classpath`() {
+    val loadClass = LoadClass()
+    assertNotNull(loadClass.loadClass("io.sentry.SentryEvent", null))
+    assertFalse(
+      loadClass.isClassAvailable("io.sentry.ThisClassDoesNotExist", null as io.sentry.ILogger?)
+    )
+  }
+
+  @Test
+  fun `isClassAvailable does not run the static initializer of the probed class`() {
+    // Reading the flag initializes the flag holder, not the probe.
+    assertFalse(IsClassAvailableNoInitFlag.initialized)
+
+    // Obtaining the name via ::class.java does not initialize the probe either.
+    LoadClass()
+      .isClassAvailable(IsClassAvailableNoInitProbe::class.java.name, null as io.sentry.ILogger?)
+
+    // Availability probing must not trigger the probe's static initializer.
+    assertFalse(IsClassAvailableNoInitFlag.initialized)
+  }
+
+  @Test
+  fun `loadClass runs the static initializer of the loaded class`() {
+    assertFalse(LoadClassInitFlag.initialized)
+
+    LoadClass().loadClass(LoadClassInitProbe::class.java.name, null)
+
+    assertTrue(LoadClassInitFlag.initialized)
+  }
+}
+
+private object IsClassAvailableNoInitFlag {
+  @JvmField var initialized = false
+}
+
+private object IsClassAvailableNoInitProbe {
+  init {
+    IsClassAvailableNoInitFlag.initialized = true
+  }
+}
+
+private object LoadClassInitFlag {
+  @JvmField var initialized = false
+}
+
+private object LoadClassInitProbe {
+  init {
+    LoadClassInitFlag.initialized = true
+  }
+}

From e279b061f72b2bbcf3b1b3c178024933e0031f60 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 30 Jun 2026 11:45:14 +0200
Subject: [PATCH 249/391] perf(android): Avoid exception-driven control flow in
 getResourceId (#5631)

* perf(android): Avoid exception-driven control flow in getResourceId

ViewUtils.getResourceId threw Resources.NotFoundException for views with
no id or a generated id, and callers caught and discarded it. During a
view-hierarchy snapshot and on every gesture this ran per view, so in
Compose-heavy apps where most views have generated ids the SDK
constructed an exception (and a native stack trace fill) per view on the
main thread.

Add a non-throwing resolveResourceId that returns null for unresolved
ids and route the hot callers through it. The public getResourceId
remains as a throwing wrapper for backward compatibility. Behavior
(emitted identifiers and fallbacks) is unchanged.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   1 +
 .../core/ViewHierarchyEventProcessor.java     |   6 +-
 .../AndroidViewGestureTargetLocator.java      |  10 +-
 .../core/internal/gestures/ViewUtils.java     |  29 ++--
 .../core/internal/gestures/ViewUtilsTest.kt   | 126 ++++++++----------
 5 files changed, 85 insertions(+), 87 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dce1fd22d22..6f9baf77a16 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,7 @@
 
 - Speed up touch gesture target detection on deeply nested view hierarchies by hit-testing in local coordinates instead of calling `getLocationOnScreen` per view ([#5595](https://github.com/getsentry/sentry-java/pull/5595))
 - Probe class availability without initializing the class during SDK init ([#5635](https://github.com/getsentry/sentry-java/pull/5635))
+- Avoid constructing an exception per view when resolving view ids during view-hierarchy and gesture capture ([#5631](https://github.com/getsentry/sentry-java/pull/5631))
 
 ## 8.46.0
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ViewHierarchyEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ViewHierarchyEventProcessor.java
index c32b05892f9..7090985a38b 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ViewHierarchyEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ViewHierarchyEventProcessor.java
@@ -256,8 +256,10 @@ private static ViewHierarchyNode viewToNode(@NotNull final View view) {
     node.setType(className);
 
     try {
-      final String identifier = ViewUtils.getResourceId(view);
-      node.setIdentifier(identifier);
+      final @Nullable String identifier = ViewUtils.getResourceIdOrNull(view);
+      if (identifier != null) {
+        node.setIdentifier(identifier);
+      }
     } catch (Throwable e) {
       // ignored
     }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/AndroidViewGestureTargetLocator.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/AndroidViewGestureTargetLocator.java
index c85fb80dc35..5f6187cd39a 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/AndroidViewGestureTargetLocator.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/AndroidViewGestureTargetLocator.java
@@ -1,6 +1,5 @@
 package io.sentry.android.core.internal.gestures;
 
-import android.content.res.Resources;
 import android.view.View;
 import android.widget.AbsListView;
 import android.widget.ScrollView;
@@ -42,13 +41,12 @@ && isViewScrollable(view, isAndroidXAvailable.getValue())) {
   }
 
   private UiElement createUiElement(final @NotNull View targetView) {
-    try {
-      final String resourceName = ViewUtils.getResourceId(targetView);
-      @Nullable String className = ClassUtil.getClassName(targetView);
-      return new UiElement(targetView, className, resourceName, null, ORIGIN);
-    } catch (Resources.NotFoundException ignored) {
+    final @Nullable String resourceName = ViewUtils.getResourceIdOrNull(targetView);
+    if (resourceName == null) {
       return null;
     }
+    @Nullable String className = ClassUtil.getClassName(targetView);
+    return new UiElement(targetView, className, resourceName, null, ORIGIN);
   }
 
   private static boolean isViewTappable(final @NotNull View view) {
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/ViewUtils.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/ViewUtils.java
index 6f52612e50d..78c73713bd4 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/ViewUtils.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/ViewUtils.java
@@ -150,32 +150,37 @@ private static final class ViewWithLocation {
    * @return human-readable view id
    */
   static String getResourceIdWithFallback(final @NotNull View view) {
-    final int viewId = view.getId();
-    try {
-      return getResourceId(view);
-    } catch (Resources.NotFoundException e) {
+    final @Nullable String resourceId = getResourceIdOrNull(view);
+    if (resourceId == null) {
       // fall back to hex representation of the id
-      return "0x" + Integer.toString(viewId, 16);
+      return "0x" + Integer.toString(view.getId(), 16);
     }
+    return resourceId;
   }
 
   /**
-   * Retrieves the human-readable view id based on {@code view.getContext().getResources()}.
+   * Retrieves the human-readable view id based on {@code view.getContext().getResources()}, or
+   * {@code null} when the view has no resource-backed id. Returning {@code null} rather than
+   * throwing avoids exception-driven control flow on hot, main-thread paths such as view-hierarchy
+   * snapshots and gesture target resolution.
    *
    * @param view - the view whose id is being retrieved
-   * @return human-readable view id
-   * @throws Resources.NotFoundException in case the view id was not found
+   * @return human-readable view id, or {@code null} if it cannot be resolved
    */
-  public static String getResourceId(final @NotNull View view) throws Resources.NotFoundException {
+  public static @Nullable String getResourceIdOrNull(final @NotNull View view) {
     final int viewId = view.getId();
     if (viewId == View.NO_ID || isViewIdGenerated(viewId)) {
-      throw new Resources.NotFoundException();
+      return null;
     }
     final Resources resources = view.getContext().getResources();
-    if (resources != null) {
+    if (resources == null) {
+      return "";
+    }
+    try {
       return resources.getResourceEntryName(viewId);
+    } catch (Resources.NotFoundException e) {
+      return null;
     }
-    return "";
   }
 
   private static boolean isViewIdGenerated(int id) {
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewUtilsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewUtilsTest.kt
index 10064b1cd74..ed3e6d8ca89 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewUtilsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/ViewUtilsTest.kt
@@ -11,13 +11,11 @@ import io.sentry.internal.gestures.UiElement
 import io.sentry.util.LazyEvaluator
 import kotlin.test.Test
 import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
 import org.mockito.kotlin.doReturn
-import org.mockito.kotlin.doThrow
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
@@ -25,71 +23,6 @@ import org.mockito.kotlin.whenever
 
 @RunWith(AndroidJUnit4::class)
 class ViewUtilsTest {
-  @Test
-  fun `getResourceId returns resourceId when available`() {
-    val view =
-      mock<View> {
-        whenever(it.id).doReturn(0x7f010001)
-
-        val context = mock<Context>()
-        val resources = mock<Resources>()
-        whenever(resources.getResourceEntryName(it.id)).thenReturn("test_view")
-        whenever(context.resources).thenReturn(resources)
-        whenever(it.context).thenReturn(context)
-      }
-
-    assertEquals(ViewUtils.getResourceId(view), "test_view")
-  }
-
-  @Test
-  fun `getResourceId throws when resource id is not available`() {
-    val view =
-      mock<View> {
-        whenever(it.id).doReturn(View.generateViewId())
-
-        val context = mock<Context>()
-        val resources = mock<Resources>()
-        whenever(resources.getResourceEntryName(any())).doThrow(Resources.NotFoundException())
-        whenever(context.resources).thenReturn(resources)
-        whenever(it.context).thenReturn(context)
-      }
-
-    assertFailsWith<Resources.NotFoundException> { ViewUtils.getResourceId(view) }
-  }
-
-  @Test
-  fun `when view has no id set, resource name is not looked up `() {
-    val context = mock<Context>()
-    val resources = mock<Resources>()
-    whenever(context.resources).thenReturn(resources)
-
-    val view =
-      mock<View> {
-        whenever(it.id).doReturn(View.NO_ID)
-        whenever(it.context).thenReturn(context)
-      }
-
-    assertFailsWith<Resources.NotFoundException> { ViewUtils.getResourceId(view) }
-    verify(context, never()).resources
-  }
-
-  @Test
-  fun `when view id is generated, resource name is not looked up `() {
-    val context = mock<Context>()
-    val resources = mock<Resources>()
-    whenever(context.resources).thenReturn(resources)
-
-    val view =
-      mock<View> {
-        // View.generateViewId() starts with 1
-        whenever(it.id).doReturn(1)
-        whenever(it.context).thenReturn(context)
-      }
-
-    assertFailsWith<Resources.NotFoundException> { ViewUtils.getResourceId(view) }
-    verify(context, never()).resources
-  }
-
   @Test
   fun `findTarget hit-tests children in their own local coordinate space`() {
     val child = clickableChild()
@@ -178,6 +111,65 @@ class ViewUtilsTest {
       gestureTargetLocators = listOf(AndroidViewGestureTargetLocator(LazyEvaluator { true }))
     }
 
+  @Test
+  fun `getResourceIdOrNull returns resource name when available`() {
+    val view =
+      mock<View> {
+        whenever(it.id).doReturn(0x7f010001)
+
+        val context = mock<Context>()
+        val resources = mock<Resources>()
+        whenever(resources.getResourceEntryName(it.id)).thenReturn("test_view")
+        whenever(context.resources).thenReturn(resources)
+        whenever(it.context).thenReturn(context)
+      }
+
+    assertEquals("test_view", ViewUtils.getResourceIdOrNull(view))
+  }
+
+  @Test
+  fun `getResourceIdOrNull returns null without throwing for generated id`() {
+    val context = mock<Context>()
+    val view =
+      mock<View> {
+        // View.generateViewId() starts with 1
+        whenever(it.id).doReturn(1)
+        whenever(it.context).thenReturn(context)
+      }
+
+    assertNull(ViewUtils.getResourceIdOrNull(view))
+    verify(context, never()).resources
+  }
+
+  @Test
+  fun `getResourceIdOrNull returns null without throwing when view has no id`() {
+    val context = mock<Context>()
+    val view =
+      mock<View> {
+        whenever(it.id).doReturn(View.NO_ID)
+        whenever(it.context).thenReturn(context)
+      }
+
+    assertNull(ViewUtils.getResourceIdOrNull(view))
+    verify(context, never()).resources
+  }
+
+  @Test
+  fun `getResourceIdOrNull returns null without throwing when resource not found`() {
+    val view =
+      mock<View> {
+        whenever(it.id).doReturn(1234)
+
+        val context = mock<Context>()
+        val resources = mock<Resources>()
+        whenever(resources.getResourceEntryName(it.id)).thenThrow(Resources.NotFoundException())
+        whenever(context.resources).thenReturn(resources)
+        whenever(it.context).thenReturn(context)
+      }
+
+    assertNull(ViewUtils.getResourceIdOrNull(view))
+  }
+
   @Test
   fun `getResourceIdWithFallback falls back to hexadecimal id when resource not found`() {
     val view =

From 3859a2cc37716e2c8d9f149a0d94a1552f22c248 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 30 Jun 2026 11:58:42 +0200
Subject: [PATCH 250/391] perf(android): Defer SentryFrameMetricsCollector
 thread startup (#5641)

* perf(android): Start frame metrics thread lazily on first collection

SentryFrameMetricsCollector created and started its HandlerThread in the
constructor, blocking the calling thread (the main thread during SDK
init) on HandlerThread.getLooper(). The handler is only needed once
startCollection() registers a listener, so start the thread lazily there
instead. Apps that never collect frame metrics no longer start the
thread at all.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../util/SentryFrameMetricsCollector.java     | 35 +++++++++++++++----
 .../util/SentryFrameMetricsCollectorTest.kt   | 10 ++++++
 3 files changed, 39 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6f9baf77a16..fb4fee3db81 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@
 - Speed up touch gesture target detection on deeply nested view hierarchies by hit-testing in local coordinates instead of calling `getLocationOnScreen` per view ([#5595](https://github.com/getsentry/sentry-java/pull/5595))
 - Probe class availability without initializing the class during SDK init ([#5635](https://github.com/getsentry/sentry-java/pull/5635))
 - Avoid constructing an exception per view when resolving view ids during view-hierarchy and gesture capture ([#5631](https://github.com/getsentry/sentry-java/pull/5631))
+- Start the frame metrics thread lazily on first collection instead of during SDK init ([#5641](https://github.com/getsentry/sentry-java/pull/5641))
 
 ## 8.46.0
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
index 241ab1e4cca..4f76a51e86f 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
@@ -14,12 +14,14 @@
 import android.view.Window;
 import androidx.annotation.RequiresApi;
 import io.sentry.ILogger;
+import io.sentry.ISentryLifecycleToken;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
 import io.sentry.SentryUUID;
 import io.sentry.android.core.BuildInfoProvider;
 import io.sentry.android.core.ContextUtils;
 import io.sentry.android.core.SentryFramesDelayResult;
+import io.sentry.util.AutoClosableReentrantLock;
 import io.sentry.util.Objects;
 import java.lang.ref.WeakReference;
 import java.lang.reflect.Field;
@@ -45,7 +47,8 @@ public final class SentryFrameMetricsCollector implements Application.ActivityLi
   private final @NotNull Set<Window> trackedWindows = new CopyOnWriteArraySet<>();
 
   private final @NotNull ILogger logger;
-  private @Nullable Handler handler;
+  private volatile @Nullable Handler handler;
+  private final @NotNull AutoClosableReentrantLock handlerLock = new AutoClosableReentrantLock();
   private @Nullable WeakReference<Window> currentWindow;
   private final @NotNull Map<String, FrameMetricsCollectorListener> listenerMap =
       new ConcurrentHashMap<>();
@@ -113,12 +116,8 @@ public SentryFrameMetricsCollector(
     }
     isAvailable = true;
 
-    HandlerThread handlerThread =
-        new HandlerThread("io.sentry.android.core.internal.util.SentryFrameMetricsCollector");
-    handlerThread.setUncaughtExceptionHandler(
-        (thread, e) -> logger.log(SentryLevel.ERROR, "Error during frames measurements.", e));
-    handlerThread.start();
-    handler = new Handler(handlerThread.getLooper());
+    // The frame metrics HandlerThread is started lazily on the first startCollection() call.
+    // Starting it here would block the main thread on HandlerThread.getLooper() during SDK init.
 
     // We have to register the lifecycle callback, even if no profile is started, otherwise when we
     // start a profile, we wouldn't have the current activity and couldn't get the frameMetrics.
@@ -281,12 +280,34 @@ public void onActivityDestroyed(@NotNull Activity activity) {}
     if (!isAvailable) {
       return null;
     }
+    ensureHandlerThreadStarted();
     final String uid = SentryUUID.generateSentryId();
     listenerMap.put(uid, listener);
     trackCurrentWindow();
     return uid;
   }
 
+  /**
+   * Lazily starts the background HandlerThread used to receive frame metrics. Deferred out of the
+   * constructor because {@link HandlerThread#getLooper()} blocks the caller (the main thread during
+   * SDK init) until the thread is ready, and the handler is only needed once collection starts.
+   */
+  private void ensureHandlerThreadStarted() {
+    if (handler != null) {
+      return;
+    }
+    try (final @NotNull ISentryLifecycleToken ignored = handlerLock.acquire()) {
+      if (handler == null) {
+        final HandlerThread handlerThread =
+            new HandlerThread("io.sentry.android.core.internal.util.SentryFrameMetricsCollector");
+        handlerThread.setUncaughtExceptionHandler(
+            (thread, e) -> logger.log(SentryLevel.ERROR, "Error during frames measurements.", e));
+        handlerThread.start();
+        handler = new Handler(handlerThread.getLooper());
+      }
+    }
+  }
+
   public void stopCollection(final @Nullable String listenerId) {
     if (!isAvailable) {
       return;
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt
index 02f65665a9e..f90c07b70e6 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt
@@ -141,6 +141,16 @@ class SentryFrameMetricsCollectorTest {
     assertNotNull(id)
   }
 
+  @Test
+  fun `handler thread is started lazily on first startCollection`() {
+    val collector = fixture.getSut(context)
+    // not started during construction (would block the main thread on getLooper at SDK init)
+    assertNull(collector.getProperty<Handler?>("handler"))
+
+    collector.startCollection(mock())
+    assertNotNull(collector.getProperty<Handler?>("handler"))
+  }
+
   @Test
   fun `collector calls addOnFrameMetricsAvailableListener when an activity starts`() {
     val collector = fixture.getSut(context)

From 307edcd968452d07d801c46362bf98f815fea808 Mon Sep 17 00:00:00 2001
From: Matt Van Horn <mvanhorn@users.noreply.github.com>
Date: Tue, 30 Jun 2026 03:50:02 -0700
Subject: [PATCH 251/391] refactor: do not start redundant UI event transaction
 when one is already on Scope (#5658)

SentryGestureListener.startTracing always started a UI transaction and
only later, in applyScope, declined to bind it when the Scope already
held a manually-bound transaction. The unbound UI transaction then
gathered no children and was dropped as an idle transaction. Now we read
the Scope's bound transaction first and return early without starting a
new one when it is present.

Fixes #5491

Co-authored-by: Matt Van Horn <455140+mvanhorn@users.noreply.github.com>
---
 CHANGELOG.md                                      |  2 ++
 .../internal/gestures/SentryGestureListener.java  | 15 +++++++++++++++
 .../gestures/SentryGestureListenerTracingTest.kt  | 12 ++++++++++++
 3 files changed, 29 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fb4fee3db81..73bb2ef396e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,8 @@
 
 ### Fixes
 
+- Don't start a redundant UI interaction transaction when a transaction is already bound to the Scope ([#5491](https://github.com/getsentry/sentry-java/issues/5491))
+  - Previously, `SentryGestureListener` always started a UI transaction and only afterwards skipped binding it to the Scope when a manually-bound transaction already existed, leaving the new transaction to be dropped as an idle transaction without children.
 - Fix potential NPE within `Scope.endSession()` ([#5657](https://github.com/getsentry/sentry-java/pull/5657))
 
 ### Performance
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureListener.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureListener.java
index 8caffedad94..61a32b675db 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureListener.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/gestures/SentryGestureListener.java
@@ -244,6 +244,21 @@ private void startTracing(final @NotNull UiElement target, final @NotNull Gestur
       }
     }
 
+    // if there's already a transaction bound to the Scope (e.g. started manually by the user), we
+    // skip starting a new UI transaction: it would never be bound to the Scope in applyScope, would
+    // gather no children, and would be dropped as an idle transaction without children
+    final @Nullable ITransaction[] boundTransaction = {null};
+    scopes.configureScope(scope -> boundTransaction[0] = scope.getTransaction());
+    if (boundTransaction[0] != null) {
+      options
+          .getLogger()
+          .log(
+              SentryLevel.DEBUG,
+              "Transaction won't be created for view with id: %s since there's already a transaction bound to the Scope.",
+              viewIdentifier);
+      return;
+    }
+
     // we can only bind to the scope if there's no running transaction
     final String name = getActivityName(activity) + "." + viewIdentifier;
     final String op = UI_ACTION + "." + getGestureType(eventType);
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureListenerTracingTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureListenerTracingTest.kt
index fe994f4a828..9d7606bfe44 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureListenerTracingTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/gestures/SentryGestureListenerTracingTest.kt
@@ -160,6 +160,18 @@ class SentryGestureListenerTracingTest {
     sut.onSingleTapUp(fixture.event)
   }
 
+  @Test
+  fun `when a transaction is already bound to the Scope, does not start a new UI transaction`() {
+    val sut = fixture.getSut<View>()
+    val boundTransaction = SentryTracer(TransactionContext("bound", "op"), fixture.scopes)
+    whenever(fixture.scope.transaction).thenReturn(boundTransaction)
+
+    sut.onSingleTapUp(fixture.event)
+
+    verify(fixture.scopes, never()).startTransaction(any(), any<TransactionOptions>())
+    assertEquals(false, boundTransaction.isFinished)
+  }
+
   @Test
   fun `stopTracing remove transaction from scope`() {
     val sut = fixture.getSut<View>()

From 58b65f0fd57114f98e9f2bd4517e8ffae1d51e05 Mon Sep 17 00:00:00 2001
From: Antonis Lilis <antonis.lilis@gmail.com>
Date: Wed, 1 Jul 2026 11:48:59 +0200
Subject: [PATCH 252/391] chore: Add PR template checkbox for cross sdk review
 on public API changes (#5665)

Add PR template checkbox for cross sdk review on public API changes
---
 .github/pull_request_template.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index b337ac9ea4e..e4a12165077 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -25,6 +25,7 @@
 - [ ] Review from the native team if needed.
 - [ ] No breaking change or entry added to the changelog.
 - [ ] No breaking change for hybrid SDKs or communicated to hybrid SDKs.
+- [ ] Public API changes reviewed by another Mobile SDK team member or implemented according to the [develop docs](https://develop.sentry.dev/) spec.
 
 
 ## :crystal_ball: Next steps

From d06126055527212a23f245ea8640d20b61bb5cd2 Mon Sep 17 00:00:00 2001
From: tsushanth <78000697+tsushanth@users.noreply.github.com>
Date: Thu, 2 Jul 2026 00:32:56 -0700
Subject: [PATCH 253/391] fix: guard executor shutdown in
 BaseCaptureStrategy.stop() (#5627)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix: guard executor shutdown in BaseCaptureStrategy.stop()

Each start/stop cycle leaked one SentryReplayPersister-* thread because
stop() reset delegated properties (segmentTimestamp, currentReplayId)
whose setters dispatch to persistingExecutor, initialising the lazy —
but stop() never shut it down.

Replace the lazy delegate with an explicit nullable holder so the
executor is only created when actually needed and can be detected at
stop() time.  Call shutdownNow() (non-blocking) rather than the blocking
shutdown() to avoid ANRs when stop() runs on the main thread.

Fixes #5564

* style: apply spotless formatting

* refactor(replay): move persistingExecutor ownership to ReplayIntegration

Move persistingExecutor out of BaseCaptureStrategy and into
ReplayIntegration, passing it as a constructor argument to CaptureStrategy
subclasses. Shut it down in ReplayIntegration.close() alongside
replayExecutor so executor lifecycle is managed in one place.

* Fix leak in ReplayIntegration due to persisting executor not being shut down

Add the persistingExecutor argument to SessionCaptureStrategy and
BufferCaptureStrategy constructor calls in tests, and add changelog entry.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Remove stray merge conflict marker from CHANGELOG.md

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Remove no-op leak test from SessionCaptureStrategyTest

The test used a mocked executor that never spawned threads, so the
thread-count assertion was always true regardless of the fix.
The executor lifecycle is now owned by ReplayIntegration, not
SessionCaptureStrategy, so the test belonged at the wrong layer.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Add executor leak regression test to ReplayIntegrationTest

Uses real ScheduledThreadPoolExecutor threads so the test actually
fails if the shutdown in close() is removed.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Use shutdownNow() for replay executors in close() to avoid ANR

shutdown() calls awaitTermination() which blocks up to
shutdownTimeoutMillis. Since close() can run on the main thread
(via Sentry.close() from hybrid SDKs), this risks an ANR.
shutdownNow() is non-blocking and sufficient at teardown.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../android/replay/ReplayIntegration.kt       | 36 +++++++++++++++++--
 .../replay/capture/BaseCaptureStrategy.kt     | 19 +---------
 .../replay/capture/BufferCaptureStrategy.kt   |  8 +++--
 .../replay/capture/SessionCaptureStrategy.kt  | 11 +++++-
 .../replay/util/ReplayExecutorService.kt      |  8 +++++
 .../android/replay/ReplayIntegrationTest.kt   | 27 ++++++++++++++
 .../capture/BufferCaptureStrategyTest.kt      |  6 ++++
 .../capture/SessionCaptureStrategyTest.kt     |  8 +++++
 9 files changed, 101 insertions(+), 23 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 73bb2ef396e..b2f260761b3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@
 - Don't start a redundant UI interaction transaction when a transaction is already bound to the Scope ([#5491](https://github.com/getsentry/sentry-java/issues/5491))
   - Previously, `SentryGestureListener` always started a UI transaction and only afterwards skipped binding it to the Scope when a manually-bound transaction already existed, leaving the new transaction to be dropped as an idle transaction without children.
 - Fix potential NPE within `Scope.endSession()` ([#5657](https://github.com/getsentry/sentry-java/pull/5657))
+- Fix memory leak in `ReplayIntegration` due to persisting executor not being shut down ([#5627](https://github.com/getsentry/sentry-java/pull/5627))
 
 ### Performance
 
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
index 116ab45af06..612517438f6 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
@@ -107,10 +107,17 @@ public class ReplayIntegration(
   private var gestureRecorder: GestureRecorder? = null
   private val random by lazy { Random() }
   internal val rootViewsSpy by lazy { RootViewsSpy.install() }
-  private val replayExecutor by lazy {
+  internal val lazyReplayExecutor = lazy {
     val delegate = Executors.newSingleThreadScheduledExecutor(ReplayExecutorServiceThreadFactory())
     ReplayExecutorService(delegate, options)
   }
+  internal val replayExecutor by lazyReplayExecutor
+  internal val lazyPersistingExecutor = lazy {
+    val delegate =
+      Executors.newSingleThreadScheduledExecutor(ReplayPersistingExecutorServiceThreadFactory())
+    ReplayExecutorService(delegate, options)
+  }
+  internal val persistingExecutor by lazyPersistingExecutor
 
   internal val isEnabled = AtomicBoolean(false)
   internal val isManualPause = AtomicBoolean(false)
@@ -192,6 +199,7 @@ public class ReplayIntegration(
               scopes,
               dateProvider,
               replayExecutor,
+              persistingExecutor,
               replayCacheProvider,
             )
           } else {
@@ -201,6 +209,7 @@ public class ReplayIntegration(
               dateProvider,
               random,
               replayExecutor,
+              persistingExecutor,
               replayCacheProvider,
             )
           }
@@ -373,7 +382,20 @@ public class ReplayIntegration(
       recorder?.close()
       recorder = null
       rootViewsSpy.close()
-      replayExecutor.shutdown()
+      if (lazyReplayExecutor.isInitialized()) {
+        if (options.threadChecker.isMainThread) {
+          replayExecutor.gracefulShutdown()
+        } else {
+          replayExecutor.shutdown()
+        }
+      }
+      if (lazyPersistingExecutor.isInitialized()) {
+        if (options.threadChecker.isMainThread) {
+          persistingExecutor.gracefulShutdown()
+        } else {
+          persistingExecutor.shutdown()
+        }
+      }
       lifecycle.currentState = CLOSED
     }
   }
@@ -554,4 +576,14 @@ public class ReplayIntegration(
       return ret
     }
   }
+
+  private class ReplayPersistingExecutorServiceThreadFactory : ThreadFactory {
+    private var cnt = 0
+
+    override fun newThread(r: Runnable): Thread {
+      val ret = Thread(r, "SentryReplayPersister-" + cnt++)
+      ret.setDaemon(true)
+      return ret
+    }
+  }
 }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
index dab98ec4e24..6bb58c5e2a2 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
@@ -25,7 +25,6 @@ import io.sentry.android.replay.ScreenshotRecorderConfig
 import io.sentry.android.replay.capture.CaptureStrategy.Companion.createSegment
 import io.sentry.android.replay.capture.CaptureStrategy.ReplaySegment
 import io.sentry.android.replay.gestures.ReplayGestureConverter
-import io.sentry.android.replay.util.ReplayExecutorService
 import io.sentry.android.replay.util.ReplayRunnable
 import io.sentry.protocol.SentryId
 import io.sentry.rrweb.RRWebEvent
@@ -34,9 +33,7 @@ import java.io.File
 import java.util.Date
 import java.util.Deque
 import java.util.concurrent.ConcurrentLinkedDeque
-import java.util.concurrent.Executors
 import java.util.concurrent.ScheduledExecutorService
-import java.util.concurrent.ThreadFactory
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.atomic.AtomicReference
@@ -50,6 +47,7 @@ internal abstract class BaseCaptureStrategy(
   private val scopes: IScopes?,
   private val dateProvider: ICurrentDateProvider,
   protected val replayExecutor: ScheduledExecutorService,
+  protected val persistingExecutor: ScheduledExecutorService,
   private val replayCacheProvider: ((replayId: SentryId) -> ReplayCache)? = null,
 ) : CaptureStrategy {
   internal companion object {
@@ -58,11 +56,6 @@ internal abstract class BaseCaptureStrategy(
     private const val MAX_TRACE_IDS = 100
   }
 
-  private val persistingExecutor: ScheduledExecutorService by lazy {
-    val delegate =
-      Executors.newSingleThreadScheduledExecutor(ReplayPersistingExecutorServiceThreadFactory())
-    ReplayExecutorService(delegate, options)
-  }
   private val gestureConverter = ReplayGestureConverter(dateProvider)
 
   protected val isTerminating = AtomicBoolean(false)
@@ -192,16 +185,6 @@ internal abstract class BaseCaptureStrategy(
     }
   }
 
-  private class ReplayPersistingExecutorServiceThreadFactory : ThreadFactory {
-    private var cnt = 0
-
-    override fun newThread(r: Runnable): Thread {
-      val ret = Thread(r, "SentryReplayPersister-" + cnt++)
-      ret.setDaemon(true)
-      return ret
-    }
-  }
-
   private inline fun <T> persistableAtomicNullable(
     initialValue: T? = null,
     propertyName: String,
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
index 0eea2043bd8..0df8a642f63 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
@@ -33,6 +33,7 @@ internal class BufferCaptureStrategy(
   private val dateProvider: ICurrentDateProvider,
   private val random: Random,
   executor: ScheduledExecutorService,
+  persistingExecutor: ScheduledExecutorService,
   replayCacheProvider: ((replayId: SentryId) -> ReplayCache)? = null,
 ) :
   BaseCaptureStrategy(
@@ -40,6 +41,7 @@ internal class BufferCaptureStrategy(
     scopes,
     dateProvider,
     executor,
+    persistingExecutor,
     replayCacheProvider = replayCacheProvider,
   ) {
   // TODO: capture envelopes for buffered segments instead, but don't send them until buffer is
@@ -150,8 +152,10 @@ internal class BufferCaptureStrategy(
       )
       return this
     }
-    // we hand over replayExecutor to the new strategy to preserve order of execution
-    val captureStrategy = SessionCaptureStrategy(options, scopes, dateProvider, replayExecutor)
+    // we hand over replayExecutor and persistingExecutor to the new strategy to preserve order of
+    // execution
+    val captureStrategy =
+      SessionCaptureStrategy(options, scopes, dateProvider, replayExecutor, persistingExecutor)
     captureStrategy.recorderConfig = recorderConfig
     captureStrategy.start(
       segmentId = currentSegment,
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/SessionCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/SessionCaptureStrategy.kt
index 4d3ee588f01..d62efb534cc 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/SessionCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/SessionCaptureStrategy.kt
@@ -21,8 +21,17 @@ internal class SessionCaptureStrategy(
   private val scopes: IScopes?,
   private val dateProvider: ICurrentDateProvider,
   executor: ScheduledExecutorService,
+  persistingExecutor: ScheduledExecutorService,
   replayCacheProvider: ((replayId: SentryId) -> ReplayCache)? = null,
-) : BaseCaptureStrategy(options, scopes, dateProvider, executor, replayCacheProvider) {
+) :
+  BaseCaptureStrategy(
+    options,
+    scopes,
+    dateProvider,
+    executor,
+    persistingExecutor,
+    replayCacheProvider,
+  ) {
   internal companion object {
     private const val TAG = "SessionCaptureStrategy"
   }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/ReplayExecutorService.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/ReplayExecutorService.kt
index 31a3279d074..9e9491f516f 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/ReplayExecutorService.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/ReplayExecutorService.kt
@@ -57,6 +57,14 @@ internal class ReplayExecutorService(
       }
     }
   }
+
+  fun gracefulShutdown() {
+    synchronized(this) {
+      if (!isShutdown) {
+        delegate.shutdown()
+      }
+    }
+  }
 }
 
 internal class ReplayRunnable(val taskName: String, delegate: Runnable) : Runnable by delegate
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
index 3df0c9f005f..61b5213e76f 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
@@ -754,6 +754,12 @@ class ReplayIntegrationTest {
                 null
               }
             },
+            mock {
+              whenever(mock.submit(any<Runnable>())).doAnswer {
+                (it.arguments[0] as Runnable).run()
+                null
+              }
+            },
           ) { _ ->
             fixture.replayCache
           }
@@ -1104,6 +1110,20 @@ class ReplayIntegrationTest {
     assertEquals(traceId, traceIdRegistered)
   }
 
+  @Test
+  fun `close shuts down replay executors`() {
+    fixture.options.cacheDirPath = tmpDir.newFolder().absolutePath
+
+    val replay = fixture.getSut(context)
+    replay.register(fixture.scopes, fixture.options)
+    replay.start()
+    replay.stop()
+    replay.close()
+
+    assertTrue(replay.replayExecutor.isShutdown)
+    assertTrue(replay.persistingExecutor.isShutdown)
+  }
+
   private fun getSessionCaptureStrategy(options: SentryOptions): SessionCaptureStrategy =
     SessionCaptureStrategy(
       options,
@@ -1116,5 +1136,12 @@ class ReplayIntegrationTest {
             null
           }
         },
+      persistingExecutor =
+        mock {
+          whenever(mock.submit(any<Runnable>())).doAnswer {
+            (it.arguments[0] as Runnable).run()
+            null
+          }
+        },
     )
 }
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/BufferCaptureStrategyTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/BufferCaptureStrategyTest.kt
index 380e9b3ce75..b5048e856ff 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/BufferCaptureStrategyTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/BufferCaptureStrategyTest.kt
@@ -111,6 +111,12 @@ class BufferCaptureStrategyTest {
             null
           }
         },
+        mock {
+          whenever(it.submit(any<Runnable>())).doAnswer { invocation ->
+            (invocation.arguments[0] as Runnable).run()
+            null
+          }
+        },
       ) { _ ->
         replayCache
       }
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt
index b5a00bc624b..dd9e6c6ce1d 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt
@@ -122,6 +122,14 @@ class SessionCaptureStrategyTest {
             .whenever(it)
             .submit(any<Runnable>())
         },
+        mock {
+          doAnswer { invocation ->
+              (invocation.arguments[0] as Runnable).run()
+              null
+            }
+            .whenever(it)
+            .submit(any<Runnable>())
+        },
       ) { _ ->
         replayCache
       }

From 0980ed763492be856f205dabfea93f14e8942878 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 2 Jul 2026 10:18:42 +0200
Subject: [PATCH 254/391] perf(core): Drop per-instance lock from SentryId and
 SpanId (#5645)

* perf(core): Drop per-instance lock from SentryId and SpanId (JAVA-589)

SentryId and SpanId stored their string value behind a
LazyEvaluator<String>, which allocates an AutoClosableReentrantLock
(a ReentrantLock with its internal Sync) plus a capturing lambda on
every instance. Since one SentryId is created per event/transaction
and one SpanId per span, this per-instance lock machinery is far
heavier than the single String it guards, and the eager string-arg
constructors gained no laziness at all.

Replace the LazyEvaluator with a plain volatile String guarded by a
double-checked synchronized(this) block. Eager constructors now assign
the value directly; the no-arg and UUID constructors still defer
UUID-string generation. Synchronization is retained because UUID
generation is non-idempotent and two racing threads must not produce
different ids.

Follow-up to the SDK Overhead Reduction work (#5499).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 sentry/src/main/java/io/sentry/SpanId.java    | 31 ++++++++++-----
 .../java/io/sentry/protocol/SentryId.java     | 39 ++++++++++++-------
 3 files changed, 46 insertions(+), 25 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b2f260761b3..2a9e71a0cf4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,7 @@
 - Probe class availability without initializing the class during SDK init ([#5635](https://github.com/getsentry/sentry-java/pull/5635))
 - Avoid constructing an exception per view when resolving view ids during view-hierarchy and gesture capture ([#5631](https://github.com/getsentry/sentry-java/pull/5631))
 - Start the frame metrics thread lazily on first collection instead of during SDK init ([#5641](https://github.com/getsentry/sentry-java/pull/5641))
+- Reduce `SentryId` and `SpanId` allocation overhead by replacing their per-instance `LazyEvaluator` (and its lock) with a lightweight lazily-generated `String`. ([#5645](https://github.com/getsentry/sentry-java/pull/5645))
 
 ## 8.46.0
 
diff --git a/sentry/src/main/java/io/sentry/SpanId.java b/sentry/src/main/java/io/sentry/SpanId.java
index fcc7f3a4f38..2048647f9f9 100644
--- a/sentry/src/main/java/io/sentry/SpanId.java
+++ b/sentry/src/main/java/io/sentry/SpanId.java
@@ -2,24 +2,35 @@
 
 import static io.sentry.util.StringUtils.PROPER_NIL_UUID;
 
-import io.sentry.util.LazyEvaluator;
 import java.io.IOException;
 import java.util.Objects;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 public final class SpanId implements JsonSerializable {
   public static final SpanId EMPTY_ID =
       new SpanId(PROPER_NIL_UUID.replace("-", "").substring(0, 16));
 
-  private final @NotNull LazyEvaluator<String> lazyValue;
+  private volatile @Nullable String value;
 
   public SpanId(final @NotNull String value) {
-    Objects.requireNonNull(value, "value is required");
-    this.lazyValue = new LazyEvaluator<>(() -> value);
+    this.value = Objects.requireNonNull(value, "value is required");
   }
 
-  public SpanId() {
-    this.lazyValue = new LazyEvaluator<>(SentryUUID::generateSpanId);
+  public SpanId() {}
+
+  private @NotNull String getValue() {
+    String result = value;
+    if (result == null) {
+      synchronized (this) {
+        result = value;
+        if (result == null) {
+          result = SentryUUID.generateSpanId();
+          value = result;
+        }
+      }
+    }
+    return result;
   }
 
   @Override
@@ -27,17 +38,17 @@ public boolean equals(Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     SpanId spanId = (SpanId) o;
-    return lazyValue.getValue().equals(spanId.lazyValue.getValue());
+    return getValue().equals(spanId.getValue());
   }
 
   @Override
   public int hashCode() {
-    return lazyValue.getValue().hashCode();
+    return getValue().hashCode();
   }
 
   @Override
   public String toString() {
-    return lazyValue.getValue();
+    return getValue();
   }
 
   // JsonElementSerializer
@@ -45,7 +56,7 @@ public String toString() {
   @Override
   public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger logger)
       throws IOException {
-    writer.value(lazyValue.getValue());
+    writer.value(getValue());
   }
 
   // JsonElementDeserializer
diff --git a/sentry/src/main/java/io/sentry/protocol/SentryId.java b/sentry/src/main/java/io/sentry/protocol/SentryId.java
index a5bd7980c3f..8d85afe4639 100644
--- a/sentry/src/main/java/io/sentry/protocol/SentryId.java
+++ b/sentry/src/main/java/io/sentry/protocol/SentryId.java
@@ -6,7 +6,6 @@
 import io.sentry.ObjectReader;
 import io.sentry.ObjectWriter;
 import io.sentry.SentryUUID;
-import io.sentry.util.LazyEvaluator;
 import io.sentry.util.StringUtils;
 import io.sentry.util.UUIDStringUtils;
 import java.io.IOException;
@@ -19,19 +18,15 @@ public final class SentryId implements JsonSerializable {
   public static final SentryId EMPTY_ID =
       new SentryId(StringUtils.PROPER_NIL_UUID.replace("-", ""));
 
-  private final @NotNull LazyEvaluator<String> lazyStringValue;
+  private volatile @Nullable String value;
+  private final @Nullable UUID uuid;
 
   public SentryId() {
     this((UUID) null);
   }
 
   public SentryId(@Nullable UUID uuid) {
-    if (uuid != null) {
-      this.lazyStringValue =
-          new LazyEvaluator<>(() -> normalize(UUIDStringUtils.toSentryIdString(uuid)));
-    } else {
-      this.lazyStringValue = new LazyEvaluator<>(SentryUUID::generateSentryId);
-    }
+    this.uuid = uuid;
   }
 
   public SentryId(final @NotNull String sentryIdString) {
@@ -42,16 +37,30 @@ public SentryId(final @NotNull String sentryIdString) {
               + "or 36 characters long (completed UUID). Received: "
               + sentryIdString);
     }
-    if (normalized.length() == 36) {
-      this.lazyStringValue = new LazyEvaluator<>(() -> normalize(normalized));
-    } else {
-      this.lazyStringValue = new LazyEvaluator<>(() -> normalized);
+    this.uuid = null;
+    this.value = normalized.length() == 36 ? normalized.replace("-", "") : normalized;
+  }
+
+  private @NotNull String getValue() {
+    String result = value;
+    if (result == null) {
+      synchronized (this) {
+        result = value;
+        if (result == null) {
+          result =
+              uuid != null
+                  ? normalize(UUIDStringUtils.toSentryIdString(uuid))
+                  : SentryUUID.generateSentryId();
+          value = result;
+        }
+      }
     }
+    return result;
   }
 
   @Override
   public String toString() {
-    return lazyStringValue.getValue();
+    return getValue();
   }
 
   @Override
@@ -59,12 +68,12 @@ public boolean equals(final @Nullable Object o) {
     if (this == o) return true;
     if (o == null || getClass() != o.getClass()) return false;
     SentryId sentryId = (SentryId) o;
-    return lazyStringValue.getValue().equals(sentryId.lazyStringValue.getValue());
+    return getValue().equals(sentryId.getValue());
   }
 
   @Override
   public int hashCode() {
-    return lazyStringValue.getValue().hashCode();
+    return getValue().hashCode();
   }
 
   private @NotNull String normalize(@NotNull String uuidString) {

From 30862fca3f9c52541d12e1d966e19f22ed22d402 Mon Sep 17 00:00:00 2001
From: tsushanth <78000697+tsushanth@users.noreply.github.com>
Date: Thu, 2 Jul 2026 01:23:22 -0700
Subject: [PATCH 255/391] fix(compose): add isImportantForBounds() to
 SentryTagModifierNode for compose-ui 1.11+ (#5672)

* fix(compose): add isImportantForBounds() to SentryTagModifierNode for compose-ui 1.11+

compose-ui 1.11 added SemanticsModifierNode.isImportantForBounds() as an
abstract method. SentryTagModifierNode was compiled against compose-ui 1.6.x,
where the method does not exist, so its bytecode lacks an implementation.
When an accessibility client (TalkBack, UiAutomator, adb uiautomator dump)
traverses the Compose semantics tree at runtime on 1.11+, the JVM cannot find
the method and throws AbstractMethodError.

Adding fun isImportantForBounds(): Boolean = false without the override keyword
(since the method is absent from the 1.6.x compile-time dependency) places the
method in the class bytecode. The JVM satisfies the abstract method requirement
via signature matching at runtime. SentryTagModifierNode stores only a semantic
tag with no layout/visual effect, so false is the correct return value.

* fix formatting

* chore(changelog): Add Changelog entry

---------

Co-authored-by: Markus Hintersteiner <markus.hintersteiner@sentry.io>
---
 CHANGELOG.md                                           |  1 +
 .../kotlin/io/sentry/compose/SentryModifier.kt         | 10 ++++++++++
 2 files changed, 11 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2a9e71a0cf4..31c600cbcf4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@
   - Previously, `SentryGestureListener` always started a UI transaction and only afterwards skipped binding it to the Scope when a manually-bound transaction already existed, leaving the new transaction to be dropped as an idle transaction without children.
 - Fix potential NPE within `Scope.endSession()` ([#5657](https://github.com/getsentry/sentry-java/pull/5657))
 - Fix memory leak in `ReplayIntegration` due to persisting executor not being shut down ([#5627](https://github.com/getsentry/sentry-java/pull/5627))
+- Fix AbstractMethodError when compose-ui 1.11+ is used in combination with `Modifier.sentryTag()` or the Sentry Kotlin compiler plugin ([#5672](https://github.com/getsentry/sentry-java/pull/5672))
 
 ### Performance
 
diff --git a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryModifier.kt b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryModifier.kt
index 3fec407987b..787c66b3b0b 100644
--- a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryModifier.kt
+++ b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryModifier.kt
@@ -53,5 +53,15 @@ public object SentryModifier {
     override fun SemanticsPropertyReceiver.applySemantics() {
       this[SentryTag] = tag
     }
+
+    // SemanticsModifierNode.isImportantForBounds() was added as an abstract method in
+    // compose-ui 1.11.  Classes compiled against earlier versions lack this method in
+    // their bytecode, which causes AbstractMethodError when the accessibility tree is
+    // traversed on 1.11+ runtimes.  We can't use the `override` keyword here because
+    // the method doesn't exist in the compile-time dependency (compose-ui 1.6.x), but
+    // the JVM satisfies the abstract-method requirement at runtime via signature
+    // matching.  SentryTagModifierNode only stores a semantic tag and has no visual
+    // effect on layout, so it is not important for bounds.
+    @Suppress("unused") fun isImportantForBounds(): Boolean = false
   }
 }

From 4414d9f4cd5601bee4c95f72a868b2c1ddff1f80 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 2 Jul 2026 10:27:25 +0200
Subject: [PATCH 256/391] build: Remove global per-test JVM heap cap (#5671)

* build: Remove global per-test JVM heap cap

The minHeapSize/maxHeapSize cap in the root build.gradle.kts was applied
to every module's test task. Most modules do not need it, so remove it
and let tests use the JVM defaults. If a specific module turns out to
require a larger heap, the cap can be re-added to that module only.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* build: Restore per-test heap cap for sentry-android-core

CI showed :sentry-android-core:testReleaseUnitTest fails with
OutOfMemoryError (Robolectric loading the android-all jar) once the
global cap is removed. Restore the 256m/2g cap for this module only,
where it is actually needed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* build: Drop stale comment about root build.gradle.kts

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 build.gradle.kts                     | 4 ----
 sentry-android-core/build.gradle.kts | 6 ++++++
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 93c82cd8c9a..2e334f43a65 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -103,10 +103,6 @@ allprojects {
                 TestLogEvent.PASSED,
                 TestLogEvent.FAILED
             )
-
-            // Cap JVM args per test
-            minHeapSize = "256m"
-            maxHeapSize = "2g"
         }
         withType<JavaCompile>().configureEach {
             options.compilerArgs.addAll(arrayOf("-Xlint:all", "-Werror", "-Xlint:-classfile", "-Xlint:-processing", "-Xlint:-try"))
diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index f7440b19494..0388b7de486 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -40,6 +40,12 @@ android {
     unitTests.apply {
       isReturnDefaultValues = true
       isIncludeAndroidResources = true
+      // Robolectric loads the android-all jar into each test JVM, which needs more heap
+      // than the default.
+      all {
+        it.minHeapSize = "256m"
+        it.maxHeapSize = "2g"
+      }
     }
   }
 

From ea2a517b565d0dc5c37a0e2f22f68324f0fc724f Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 2 Jul 2026 11:23:30 +0200
Subject: [PATCH 257/391] perf(core): Lazily allocate AutoClosableReentrantLock
 (JAVA-588) (#5643)

* perf(core): Lazily allocate AutoClosableReentrantLock (JAVA-588)

AutoClosableReentrantLock extended ReentrantLock, so every SDK object
holding one allocated a ReentrantLock (and its AbstractQueuedSynchronizer)
eagerly in its field initializer. A customer Perfetto trace showed ~81 such
allocations on the main thread during SentryAndroid.init, many for locks
that are never acquired during init.

Hold the ReentrantLock internally and create it lazily on first acquire(),
using an AtomicReferenceFieldUpdater CAS so creation stays atomic and
Loom-friendly (no synchronized, preserving #3715). Every call site uses
acquire() only, so dropping the ReentrantLock superclass touches no caller.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* perf(core): Harden lazy lock init and mark AutoClosableReentrantLock internal (JAVA-588)

Replace the unreachable candidate fallback after a failed CAS with an
explicit non-null check, so a broken invariant fails loudly instead of
handing two threads different locks. Mark the class @ApiStatus.Internal
and make the lazy-allocation test assert the lock field directly.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* perf(core): Return the lock itself as the lifecycle token (JAVA-588)

Every acquire() allocated a fresh lifecycle token, which is per-use
garbage on every lock acquisition forever, not just at init. The token
was stateless apart from its lock reference, so AutoClosableReentrantLock
now implements ISentryLifecycleToken itself and acquire() returns this,
making the steady-state acquire/close path allocation-free. Semantics
are unchanged: try-with-resources closes once per acquire, so reentrant
acquires stay balanced, and unlocking without holding the lock still
throws IllegalMonitorStateException.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 sentry/api/sentry.api                         |  3 +-
 .../util/AutoClosableReentrantLock.java       | 69 +++++++++++++++----
 .../util/AutoClosableReentrantLockTest.kt     | 58 ++++++++++++++++
 4 files changed, 116 insertions(+), 15 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 31c600cbcf4..95a6a5b5f67 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,6 +21,7 @@
 - Avoid constructing an exception per view when resolving view ids during view-hierarchy and gesture capture ([#5631](https://github.com/getsentry/sentry-java/pull/5631))
 - Start the frame metrics thread lazily on first collection instead of during SDK init ([#5641](https://github.com/getsentry/sentry-java/pull/5641))
 - Reduce `SentryId` and `SpanId` allocation overhead by replacing their per-instance `LazyEvaluator` (and its lock) with a lightweight lazily-generated `String`. ([#5645](https://github.com/getsentry/sentry-java/pull/5645))
+- Lazily allocate the `ReentrantLock` backing `AutoClosableReentrantLock` to avoid eager lock allocations for SDK objects that never contend during `SentryAndroid.init` ([#5643](https://github.com/getsentry/sentry-java/pull/5643))
 
 ## 8.46.0
 
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 04c876fdbdb..383ea92b116 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -7589,9 +7589,10 @@ public abstract class io/sentry/transport/TransportResult {
 	public static fun success ()Lio/sentry/transport/TransportResult;
 }
 
-public final class io/sentry/util/AutoClosableReentrantLock : java/util/concurrent/locks/ReentrantLock {
+public final class io/sentry/util/AutoClosableReentrantLock : io/sentry/ISentryLifecycleToken {
 	public fun <init> ()V
 	public fun acquire ()Lio/sentry/ISentryLifecycleToken;
+	public fun close ()V
 }
 
 public final class io/sentry/util/CheckInUtils {
diff --git a/sentry/src/main/java/io/sentry/util/AutoClosableReentrantLock.java b/sentry/src/main/java/io/sentry/util/AutoClosableReentrantLock.java
index 2a95a58b5fe..cf53d860e08 100644
--- a/sentry/src/main/java/io/sentry/util/AutoClosableReentrantLock.java
+++ b/sentry/src/main/java/io/sentry/util/AutoClosableReentrantLock.java
@@ -1,29 +1,70 @@
 package io.sentry.util;
 
 import io.sentry.ISentryLifecycleToken;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import java.util.concurrent.locks.ReentrantLock;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
 
-public final class AutoClosableReentrantLock extends ReentrantLock {
+/**
+ * Hands out an {@link ISentryLifecycleToken} from {@link #acquire()} for use with
+ * try-with-resources (replacing {@code synchronized} blocks).
+ *
+ * <p>The underlying {@link ReentrantLock} is created lazily on the first {@link #acquire()}. Many
+ * SDK objects hold a lock but never contend on it (especially during {@code SentryAndroid.init}),
+ * so the eager allocation of a {@link ReentrantLock} (and its {@code AbstractQueuedSynchronizer})
+ * was pure GC and main-thread overhead. We keep a {@link ReentrantLock} rather than reverting to
+ * {@code synchronized} to stay friendly to virtual threads (Loom), see #3715.
+ *
+ * <p>{@link #acquire()} returns this instance as the token, so the steady-state acquire/close path
+ * allocates nothing. Reentrant acquires stay balanced because try-with-resources calls {@link
+ * #close()} exactly once per acquire.
+ */
+@ApiStatus.Internal
+public final class AutoClosableReentrantLock implements ISentryLifecycleToken {
 
-  private static final long serialVersionUID = -3283069816958445549L;
+  private static final @NotNull AtomicReferenceFieldUpdater<
+          AutoClosableReentrantLock, ReentrantLock>
+      LOCK_UPDATER =
+          AtomicReferenceFieldUpdater.newUpdater(
+              AutoClosableReentrantLock.class, ReentrantLock.class, "lock");
 
-  public ISentryLifecycleToken acquire() {
-    lock();
-    return new AutoClosableReentrantLockLifecycleToken(this);
-  }
+  private volatile @Nullable ReentrantLock lock;
 
-  static final class AutoClosableReentrantLockLifecycleToken implements ISentryLifecycleToken {
+  public @NotNull ISentryLifecycleToken acquire() {
+    getOrCreateLock().lock();
+    return this;
+  }
 
-    private final @NotNull ReentrantLock lock;
+  @Override
+  public void close() {
+    Objects.requireNonNull(lock, "close() called before acquire()").unlock();
+  }
 
-    AutoClosableReentrantLockLifecycleToken(final @NotNull ReentrantLock lock) {
-      this.lock = lock;
+  private @NotNull ReentrantLock getOrCreateLock() {
+    final @Nullable ReentrantLock existing = lock;
+    if (existing != null) {
+      return existing;
     }
-
-    @Override
-    public void close() {
-      lock.unlock();
+    final @NotNull ReentrantLock candidate = new ReentrantLock();
+    if (LOCK_UPDATER.compareAndSet(this, null, candidate)) {
+      return candidate;
     }
+    // The CAS can only fail because another thread installed its lock first, and the field is
+    // never reset, so all callers end up contending on that same instance.
+    return Objects.requireNonNull(lock, "lock must have been set by the winning thread");
+  }
+
+  @TestOnly
+  boolean isLocked() {
+    final @Nullable ReentrantLock current = lock;
+    return current != null && current.isLocked();
+  }
+
+  @TestOnly
+  boolean isLockAllocated() {
+    return lock != null;
   }
 }
diff --git a/sentry/src/test/java/io/sentry/util/AutoClosableReentrantLockTest.kt b/sentry/src/test/java/io/sentry/util/AutoClosableReentrantLockTest.kt
index 4a69b9638e7..943a2c2bf70 100644
--- a/sentry/src/test/java/io/sentry/util/AutoClosableReentrantLockTest.kt
+++ b/sentry/src/test/java/io/sentry/util/AutoClosableReentrantLockTest.kt
@@ -1,7 +1,12 @@
 package io.sentry.util
 
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
 import kotlin.test.Test
+import kotlin.test.assertEquals
 import kotlin.test.assertFalse
+import kotlin.test.assertSame
 import kotlin.test.assertTrue
 
 class AutoClosableReentrantLockTest {
@@ -11,4 +16,57 @@ class AutoClosableReentrantLockTest {
     lock.acquire().use { assertTrue(lock.isLocked) }
     assertFalse(lock.isLocked)
   }
+
+  @Test
+  fun `acquire returns the lock itself as the token, allocating nothing`() {
+    val lock = AutoClosableReentrantLock()
+    lock.acquire().use { token -> assertSame(lock, token) }
+  }
+
+  @Test
+  fun `does not allocate the underlying lock until first acquire`() {
+    val lock = AutoClosableReentrantLock()
+    assertFalse(lock.isLockAllocated)
+    lock.acquire().use {}
+    assertTrue(lock.isLockAllocated)
+  }
+
+  @Test
+  fun `supports reentrant acquire from the same thread`() {
+    val lock = AutoClosableReentrantLock()
+    lock.acquire().use {
+      lock.acquire().use { assertTrue(lock.isLocked) }
+      assertTrue(lock.isLocked)
+    }
+    assertFalse(lock.isLocked)
+  }
+
+  @Test
+  fun `mutually excludes concurrent threads`() {
+    val lock = AutoClosableReentrantLock()
+    val inCriticalSection = AtomicInteger(0)
+    val maxObserved = AtomicInteger(0)
+    val start = CountDownLatch(1)
+    val threadCount = 8
+    val iterations = 1000
+    val threads =
+      (0 until threadCount).map {
+        Thread {
+          start.await()
+          repeat(iterations) {
+            lock.acquire().use {
+              val current = inCriticalSection.incrementAndGet()
+              maxObserved.accumulateAndGet(current, ::maxOf)
+              inCriticalSection.decrementAndGet()
+            }
+          }
+        }
+      }
+    threads.forEach(Thread::start)
+    start.countDown()
+    threads.forEach { it.join(TimeUnit.SECONDS.toMillis(10)) }
+
+    assertEquals(1, maxObserved.get())
+    assertFalse(lock.isLocked)
+  }
 }

From 844c3e85ea53e298315edb075db1fd39bfdd47f0 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 2 Jul 2026 11:24:49 +0200
Subject: [PATCH 258/391] build: Suppress obsolete Java 8 option warning under
 JDK 21+ (#5664)

The root build compiles Java with -Xlint:all -Werror. On JDK 21+,
javac flags -source/-target 8 as obsolete, and -Werror promotes that
warning to an error, failing :sentry:compileJava. CI pins JDK 17,
where the warning does not exist, so this only breaks local builds and
tooling on newer JDKs (e.g. the Kotlin LSP's bundled JDK 25, whose
Gradle project import aborts and loses cross-module resolution).

Add -Xlint:-options, the suppression javac itself recommends when
intentionally targeting an older release.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 build.gradle.kts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.gradle.kts b/build.gradle.kts
index 2e334f43a65..55b5a71a1e5 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -105,7 +105,7 @@ allprojects {
             )
         }
         withType<JavaCompile>().configureEach {
-            options.compilerArgs.addAll(arrayOf("-Xlint:all", "-Werror", "-Xlint:-classfile", "-Xlint:-processing", "-Xlint:-try"))
+            options.compilerArgs.addAll(arrayOf("-Xlint:all", "-Werror", "-Xlint:-classfile", "-Xlint:-processing", "-Xlint:-try", "-Xlint:-options"))
         }
     }
 }

From ac08f86d4a15996d553eceef3d1cdfbbfe6bcc32 Mon Sep 17 00:00:00 2001
From: markushi <1411808+markushi@users.noreply.github.com>
Date: Thu, 2 Jul 2026 09:52:17 +0000
Subject: [PATCH 259/391] release: 8.47.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 95a6a5b5f67..5c43f0976ed 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.47.0
 
 ### Behavioral Changes
 
diff --git a/gradle.properties b/gradle.properties
index 804e4b58573..4c0a1cffd1e 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.46.0
+versionName=8.47.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 7d8a3947cce374aa65ec6b9e702733ff89a0f29d Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 2 Jul 2026 13:44:30 +0200
Subject: [PATCH 260/391] fix(android-fragment): support detach/attach
 navigation in fragment tracing (#5660)

* fix(android-fragment): support detach/attach navigation in fragment tracing

For detach/attach tab navigation (manual tab switching, ViewPager v1 with
FragmentPagerAdapter, custom navigation frameworks), onFragmentCreated is
skipped for off-screen fragments that are re-attached. Previously this left
ui.load spans open until the 30s activity transaction deadline, producing
inflated performance data.

Fix by calling startTracing in onFragmentViewCreated as well as
onFragmentCreated. startTracing is idempotent (no-op if a span is already
running), so the normal onFragmentCreated -> onFragmentViewCreated path is
unaffected. Add matching stopTracing calls in onFragmentResumed (covers the
detach/attach path where onFragmentStarted may be skipped) and
onFragmentViewDestroyed (failsafe for fragments destroyed before reaching
STARTED or RESUMED). stopTracing is also idempotent, so the normal path is
unaffected.

Co-Authored-By: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>

* Format code

* Add changelog entry and detach/attach sample

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Remove duplicate test methods in fragment lifecycle test

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: Update screen name on scope for detach/attach fragment re-attachment

onFragmentCreated is skipped during detach/attach navigation, so the
screen name was never updated for re-attached fragments. Mirror the
screen tracking into onFragmentViewCreated to cover that path.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Format code

* Address PR feedback: internalize guards into startTracing and fix sample layout

Move isAdded check, screen tracking, and tracing logic into startTracing()
to deduplicate guards from onFragmentCreated and onFragmentViewCreated.
Fix DetachAttachTabsActivity sample rendering on API 35+ by using
NoActionBar theme and fitsSystemWindows.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: Decouple screen tracking from performance tracing in fragments

Screen name updates on scope should work independently of whether
performance tracing is enabled.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   1 +
 .../SentryFragmentLifecycleCallbacks.kt       |  39 ++++--
 .../SentryFragmentLifecycleCallbacksTest.kt   | 117 +++++++++++++++++-
 .../src/main/AndroidManifest.xml              |   5 +
 .../android/DetachAttachTabsActivity.kt       |  50 ++++++++
 .../io/sentry/samples/android/MainActivity.kt |  12 ++
 .../layout/activity_detach_attach_tabs.xml    |  32 +++++
 .../src/main/res/layout/fragment_tab.xml      |  12 ++
 8 files changed, 257 insertions(+), 11 deletions(-)
 create mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/DetachAttachTabsActivity.kt
 create mode 100644 sentry-samples/sentry-samples-android/src/main/res/layout/activity_detach_attach_tabs.xml
 create mode 100644 sentry-samples/sentry-samples-android/src/main/res/layout/fragment_tab.xml

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5c43f0976ed..3a290e2b3e9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
 
 ### Fixes
 
+- Fix fragment tracing not working with detach/attach navigation ([#5660](https://github.com/getsentry/sentry-java/pull/5660))
 - Don't start a redundant UI interaction transaction when a transaction is already bound to the Scope ([#5491](https://github.com/getsentry/sentry-java/issues/5491))
   - Previously, `SentryGestureListener` always started a UI transaction and only afterwards skipped binding it to the Scope when a manually-bound transaction already existed, leaving the new transaction to be dropped as an idle transaction without children.
 - Fix potential NPE within `Scope.endSession()` ([#5657](https://github.com/getsentry/sentry-java/pull/5657))
diff --git a/sentry-android-fragment/src/main/java/io/sentry/android/fragment/SentryFragmentLifecycleCallbacks.kt b/sentry-android-fragment/src/main/java/io/sentry/android/fragment/SentryFragmentLifecycleCallbacks.kt
index 230510fb4de..374713ba969 100644
--- a/sentry-android-fragment/src/main/java/io/sentry/android/fragment/SentryFragmentLifecycleCallbacks.kt
+++ b/sentry-android-fragment/src/main/java/io/sentry/android/fragment/SentryFragmentLifecycleCallbacks.kt
@@ -76,14 +76,7 @@ public class SentryFragmentLifecycleCallbacks(
   ) {
     addBreadcrumb(fragment, FragmentLifecycleState.CREATED)
 
-    // we only start the tracing for the fragment if the fragment has been added to its activity
-    // and not only to the backstack
-    if (fragment.isAdded) {
-      if (scopes.options.isEnableScreenTracking) {
-        scopes.configureScope { it.screen = getFragmentName(fragment) }
-      }
-      startTracing(fragment)
-    }
+    startTracing(fragment)
   }
 
   override fun onFragmentViewCreated(
@@ -93,17 +86,30 @@ public class SentryFragmentLifecycleCallbacks(
     savedInstanceState: Bundle?,
   ) {
     addBreadcrumb(fragment, FragmentLifecycleState.VIEW_CREATED)
+
+    // For detach/attach navigation (e.g. manual tab switching, ViewPager v1 with
+    // FragmentPagerAdapter, custom navigation frameworks), onFragmentCreated is never called for
+    // off-screen fragments that are re-attached. Starting here enables a narrower
+    // "view created -> resumed" span for those paths. startTracing is idempotent, so for the
+    // normal onFragmentCreated -> onFragmentViewCreated path this is a no-op.
+    startTracing(fragment)
   }
 
   override fun onFragmentStarted(fragmentManager: FragmentManager, fragment: Fragment) {
     addBreadcrumb(fragment, FragmentLifecycleState.STARTED)
 
-    // ViewPager2 locks background fragments to STARTED state
+    // ViewPager2 locks background fragments to STARTED state, so we stop here to avoid
+    // spans hanging for off-screen fragments that never reach RESUMED.
     stopTracing(fragment)
   }
 
   override fun onFragmentResumed(fragmentManager: FragmentManager, fragment: Fragment) {
     addBreadcrumb(fragment, FragmentLifecycleState.RESUMED)
+
+    // For detach/attach navigation, onFragmentStarted may not fire before onFragmentResumed.
+    // If a span is still running here, stop it now. stopTracing is idempotent, so this is a
+    // no-op for the normal path where onFragmentStarted already stopped the span.
+    stopTracing(fragment)
   }
 
   override fun onFragmentPaused(fragmentManager: FragmentManager, fragment: Fragment) {
@@ -116,6 +122,10 @@ public class SentryFragmentLifecycleCallbacks(
 
   override fun onFragmentViewDestroyed(fragmentManager: FragmentManager, fragment: Fragment) {
     addBreadcrumb(fragment, FragmentLifecycleState.VIEW_DESTROYED)
+
+    // Failsafe: cancel any span that didn't finish via the normal started/resumed path
+    // (e.g. fragment view destroyed before reaching STARTED or RESUMED).
+    stopTracing(fragment)
   }
 
   override fun onFragmentDestroyed(fragmentManager: FragmentManager, fragment: Fragment) {
@@ -153,6 +163,16 @@ public class SentryFragmentLifecycleCallbacks(
     fragmentsWithOngoingTransactions.containsKey(fragment)
 
   private fun startTracing(fragment: Fragment) {
+    if (!fragment.isAdded) {
+      return
+    }
+
+    val fragmentName = getFragmentName(fragment)
+
+    if (scopes.options.isEnableScreenTracking) {
+      scopes.configureScope { it.screen = fragmentName }
+    }
+
     if (!isPerformanceEnabled || isRunningSpan(fragment)) {
       return
     }
@@ -160,7 +180,6 @@ public class SentryFragmentLifecycleCallbacks(
     var transaction: ISpan? = null
     scopes.configureScope { transaction = it.transaction }
 
-    val fragmentName = getFragmentName(fragment)
     val span = transaction?.startChild(FRAGMENT_LOAD_OP, fragmentName)
 
     span?.let {
diff --git a/sentry-android-fragment/src/test/java/io/sentry/android/fragment/SentryFragmentLifecycleCallbacksTest.kt b/sentry-android-fragment/src/test/java/io/sentry/android/fragment/SentryFragmentLifecycleCallbacksTest.kt
index 9446e1caef5..997c1206398 100644
--- a/sentry-android-fragment/src/test/java/io/sentry/android/fragment/SentryFragmentLifecycleCallbacksTest.kt
+++ b/sentry-android-fragment/src/test/java/io/sentry/android/fragment/SentryFragmentLifecycleCallbacksTest.kt
@@ -43,9 +43,15 @@ class SentryFragmentLifecycleCallbacksTest {
       enableAutoFragmentLifecycleTracing: Boolean = false,
       tracesSampleRate: Double? = 1.0,
       isAdded: Boolean = true,
+      enableScreenTracking: Boolean = false,
     ): SentryFragmentLifecycleCallbacks {
       whenever(scopes.options)
-        .thenReturn(SentryOptions().apply { setTracesSampleRate(tracesSampleRate) })
+        .thenReturn(
+          SentryOptions().apply {
+            setTracesSampleRate(tracesSampleRate)
+            isEnableScreenTracking = enableScreenTracking
+          }
+        )
       whenever(span.spanContext)
         .thenReturn(SpanContext(SentryId.EMPTY_ID, SpanId.EMPTY_ID, "op", null, null))
       whenever(transaction.startChild(any<String>(), any<String>())).thenReturn(span)
@@ -251,6 +257,115 @@ class SentryFragmentLifecycleCallbacksTest {
     verify(fixture.span).finish(check { assertEquals(SpanStatus.OK, it) })
   }
 
+  @Test
+  fun `When fragment view is created via detach-attach, it should start tracing if enabled`() {
+    // Simulates detach/attach navigation: onFragmentCreated is NOT called, only
+    // onFragmentViewCreated
+    val sut = fixture.getSut(enableAutoFragmentLifecycleTracing = true)
+
+    sut.onFragmentViewCreated(
+      fixture.fragmentManager,
+      fixture.fragment,
+      view = mock(),
+      savedInstanceState = null,
+    )
+
+    verify(fixture.transaction)
+      .startChild(
+        check<String> { assertEquals(SentryFragmentLifecycleCallbacks.FRAGMENT_LOAD_OP, it) },
+        check<String> { assertEquals("androidx.fragment.app.Fragment", it) },
+      )
+  }
+
+  @Test
+  fun `When fragment view is created via detach-attach, it should update screen name`() {
+    val sut = fixture.getSut(enableAutoFragmentLifecycleTracing = true, enableScreenTracking = true)
+
+    sut.onFragmentViewCreated(
+      fixture.fragmentManager,
+      fixture.fragment,
+      view = mock(),
+      savedInstanceState = null,
+    )
+
+    verify(fixture.scope).screen = "androidx.fragment.app.Fragment"
+  }
+
+  @Test
+  fun `When performance is disabled, it should still update screen name`() {
+    val sut =
+      fixture.getSut(enableAutoFragmentLifecycleTracing = false, enableScreenTracking = true)
+
+    sut.onFragmentViewCreated(
+      fixture.fragmentManager,
+      fixture.fragment,
+      view = mock(),
+      savedInstanceState = null,
+    )
+
+    verify(fixture.scope).screen = "androidx.fragment.app.Fragment"
+    verify(fixture.transaction, never()).startChild(any<String>(), any<String>())
+  }
+
+  @Test
+  fun `When fragment view is created after onFragmentCreated, it should not start a second span`() {
+    // Normal path: onFragmentCreated already started the span; onFragmentViewCreated is a no-op
+    val sut = fixture.getSut(enableAutoFragmentLifecycleTracing = true)
+
+    sut.onFragmentCreated(fixture.fragmentManager, fixture.fragment, savedInstanceState = null)
+    sut.onFragmentViewCreated(
+      fixture.fragmentManager,
+      fixture.fragment,
+      view = mock(),
+      savedInstanceState = null,
+    )
+
+    verify(fixture.transaction).startChild(any<String>(), any<String>())
+  }
+
+  @Test
+  fun `When fragment is resumed, it should stop tracing if span is still running`() {
+    // Simulates detach/attach path where onFragmentStarted may be skipped
+    val sut = fixture.getSut(enableAutoFragmentLifecycleTracing = true)
+
+    sut.onFragmentViewCreated(
+      fixture.fragmentManager,
+      fixture.fragment,
+      view = mock(),
+      savedInstanceState = null,
+    )
+    sut.onFragmentResumed(fixture.fragmentManager, fixture.fragment)
+
+    verify(fixture.span).finish(check { assertEquals(SpanStatus.OK, it) })
+  }
+
+  @Test
+  fun `When fragment is resumed after started, it should not double-finish the span`() {
+    // Normal path: onFragmentStarted already stopped the span; onFragmentResumed is a no-op
+    val sut = fixture.getSut(enableAutoFragmentLifecycleTracing = true)
+
+    sut.onFragmentCreated(fixture.fragmentManager, fixture.fragment, savedInstanceState = null)
+    sut.onFragmentStarted(fixture.fragmentManager, fixture.fragment)
+    sut.onFragmentResumed(fixture.fragmentManager, fixture.fragment)
+
+    verify(fixture.span).finish(any())
+  }
+
+  @Test
+  fun `When fragment view is destroyed before started, it should stop tracing as failsafe`() {
+    val sut = fixture.getSut(enableAutoFragmentLifecycleTracing = true)
+
+    sut.onFragmentViewCreated(
+      fixture.fragmentManager,
+      fixture.fragment,
+      view = mock(),
+      savedInstanceState = null,
+    )
+    sut.onFragmentViewDestroyed(fixture.fragmentManager, fixture.fragment)
+
+    verify(fixture.span).finish(check { assertEquals(SpanStatus.OK, it) })
+  }
+
   private fun verifyBreadcrumbAdded(expectedState: String) {
     verify(fixture.scopes)
       .addBreadcrumb(
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 1150dd5ef2e..d72087fbfa5 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -65,6 +65,11 @@
       android:name=".ThirdActivityFragment"
       android:exported="false" />
 
+    <activity
+      android:name=".DetachAttachTabsActivity"
+      android:exported="false"
+      android:theme="@style/AppTheme.Main" />
+
     <activity
       android:name=".GesturesActivity"
       android:exported="false" />
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/DetachAttachTabsActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/DetachAttachTabsActivity.kt
new file mode 100644
index 00000000000..3a38814c5d8
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/DetachAttachTabsActivity.kt
@@ -0,0 +1,50 @@
+package io.sentry.samples.android
+
+import android.os.Bundle
+import android.view.View
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.commit
+
+class DetachAttachTabsActivity : AppCompatActivity(R.layout.activity_detach_attach_tabs) {
+
+  private val tags = arrayOf("tab_a", "tab_b")
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    findViewById<View>(R.id.btn_tab_a).setOnClickListener { showTab(0) }
+    findViewById<View>(R.id.btn_tab_b).setOnClickListener { showTab(1) }
+
+    if (savedInstanceState == null) {
+      val tabB = TabFragmentB()
+      supportFragmentManager.commit {
+        add(R.id.tab_container, TabFragmentA(), tags[0])
+        add(R.id.tab_container, tabB, tags[1])
+        detach(tabB)
+      }
+    }
+  }
+
+  private fun showTab(index: Int) {
+    supportFragmentManager.commit {
+      for (i in tags.indices) {
+        val frag = supportFragmentManager.findFragmentByTag(tags[i]) ?: continue
+        if (i == index) attach(frag) else detach(frag)
+      }
+    }
+  }
+}
+
+class TabFragmentA : Fragment(R.layout.fragment_tab) {
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    view.findViewById<TextView>(R.id.tab_label).text = "Tab A"
+  }
+}
+
+class TabFragmentB : Fragment(R.layout.fragment_tab) {
+  override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+    view.findViewById<TextView>(R.id.tab_label).text = "Tab B"
+  }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
index b87e7a3190c..d53f7e4687f 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
@@ -794,6 +794,18 @@ fun IntegrationsScreen() {
         }
       }
     }
+    item {
+      SentryTraced("open_detach_attach_tabs") {
+        OutlinedButton(
+          onClick = {
+            activity.startActivity(Intent(activity, DetachAttachTabsActivity::class.java))
+          },
+          modifier = Modifier,
+        ) {
+          Text("Open Detach/Attach Tabs", maxLines = 2, overflow = TextOverflow.Ellipsis)
+        }
+      }
+    }
     item {
       SentryTraced("open_permissions_activity") {
         OutlinedButton(
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_detach_attach_tabs.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_detach_attach_tabs.xml
new file mode 100644
index 00000000000..b2dc323d185
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_detach_attach_tabs.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:fitsSystemWindows="true">
+
+    <LinearLayout
+        android:orientation="horizontal"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:padding="8dp">
+
+        <Button
+            android:id="@+id/btn_tab_a"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Tab A" />
+
+        <Button
+            android:id="@+id/btn_tab_b"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:text="Tab B" />
+    </LinearLayout>
+
+    <FrameLayout
+        android:id="@+id/tab_container"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1" />
+</LinearLayout>
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/fragment_tab.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/fragment_tab.xml
new file mode 100644
index 00000000000..c4b46cb82fa
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/main/res/layout/fragment_tab.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <TextView
+        android:id="@+id/tab_label"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_gravity="center"
+        android:textSize="24sp" />
+</FrameLayout>

From aab952b82e72693e37e53f02ed4cc70421687d97 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 2 Jul 2026 18:00:40 +0200
Subject: [PATCH 261/391] ci(system-tests): Remove sed hacks for android module
 exclusion (#5682)

Remove the sed-based Android module exclusion from settings.gradle.kts
and build.gradle.kts in the backend system tests workflow. This is
unnecessary because org.gradle.configureondemand=true ensures Gradle
only configures projects needed for the requested tasks, and the test
runner already builds targeted sample modules rather than the whole
project.

This mirrors #5397, which removed the same sed hacks from the Spring
Boot matrix workflows.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/workflows/system-tests-backend.yml | 29 ----------------------
 1 file changed, 29 deletions(-)

diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index ed6b5eab5f7..2a05689cf46 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -122,35 +122,6 @@ jobs:
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
-      - name: Exclude android modules from build
-        run: |
-          sed -i \
-            -e '/.*"sentry-android-ndk",/d' \
-            -e '/.*"sentry-android",/d' \
-            -e '/.*"sentry-compose",/d' \
-            -e '/.*"sentry-android-core",/d' \
-            -e '/.*"sentry-android-fragment",/d' \
-            -e '/.*"sentry-android-navigation",/d' \
-            -e '/.*"sentry-android-sqlite",/d' \
-            -e '/.*"sentry-android-timber",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android-benchmark",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android",/d' \
-            -e '/.*"sentry-android-integration-tests:sentry-uitest-android-critical",/d' \
-            -e '/.*"sentry-android-integration-tests:test-app-sentry",/d' \
-            -e '/.*"sentry-samples:sentry-samples-android",/d' \
-            -e '/.*"sentry-android-replay",/d' \
-            settings.gradle.kts
-
-      - name: Exclude android modules from ignore list
-        run: |
-          sed -i \
-            -e '/.*"sentry-uitest-android",/d' \
-            -e '/.*"sentry-uitest-android-benchmark",/d' \
-            -e '/.*"sentry-uitest-android-critical",/d' \
-            -e '/.*"test-app-sentry",/d' \
-            -e '/.*"sentry-samples-android",/d' \
-            build.gradle.kts
-
       - name: Build and run system tests
         run: |
           python3 test/system-test-runner.py test --module "${{ matrix.sample }}" --agent "${{ matrix.agent }}" --auto-init "${{ matrix.agent-auto-init }}" --build "true"

From 50431640ed9e8b1465a70280d4bed9e382d6051a Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 2 Jul 2026 19:05:51 +0200
Subject: [PATCH 262/391] test(android): Add Jetpack Macrobenchmark for SDK
 init performance (JAVA-604) (#5680)

Add sentry-uitest-android-macrobenchmark, a cold-start Macrobenchmark
targeting sentry-samples-android. It reports timeToInitialDisplay from
framework trace events, requiring no trace markers in the SDK or app.
Per-iteration perfetto traces are saved for deeper analysis.

CompilationMode.Full pins ART AOT; iterations are capped at 12 because
back-to-back cold starts thermally throttle after ~14 iterations. To
A/B an SDK change, interleave per-variant rounds so thermal drift does
not systematically penalize the second variant (see README).

Verified on a Galaxy A55 (Android 16): TTID median 514.5ms over 12
iterations. Requires androidx.benchmark 1.4.1; 1.3.4 fails to confirm
activity launches on API 36.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 gradle/libs.versions.toml                     |  1 +
 .../README.md                                 | 53 +++++++++++++++++++
 .../build.gradle.kts                          | 46 ++++++++++++++++
 .../src/main/AndroidManifest.xml              |  2 +
 .../macrobenchmark/SentryStartupBenchmark.kt  | 48 +++++++++++++++++
 .../src/main/AndroidManifest.xml              |  6 +++
 settings.gradle.kts                           |  1 +
 7 files changed, 157 insertions(+)
 create mode 100644 sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/README.md
 create mode 100644 sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/build.gradle.kts
 create mode 100644 sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/AndroidManifest.xml
 create mode 100644 sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/java/io/sentry/uitest/android/macrobenchmark/SentryStartupBenchmark.kt

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 3984cb7115b..1a145040e7c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -234,6 +234,7 @@ tomcat-catalina-jakarta = { module = "org.apache.tomcat:tomcat-catalina", versio
 tomcat-embed-jasper-jakarta = { module = "org.apache.tomcat.embed:tomcat-embed-jasper", version = "11.0.22" }
 
 # test libraries
+androidx-benchmark-macro-junit4 = { module = "androidx.benchmark:benchmark-macro-junit4", version = "1.4.1" }
 androidx-compose-ui-test-junit4 = { module = "androidx.compose.ui:ui-test-junit4", version = "1.9.5" }
 androidx-test-core = { module = "androidx.test:core", version.ref = "androidxTestCore" }
 androidx-test-core-ktx = { module = "androidx.test:core-ktx", version.ref = "androidxTestCore" }
diff --git a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/README.md b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/README.md
new file mode 100644
index 00000000000..eae36ac178f
--- /dev/null
+++ b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/README.md
@@ -0,0 +1,53 @@
+# sentry-uitest-android-macrobenchmark
+
+Jetpack Macrobenchmark for cold-start of `sentry-samples-android`, used to evaluate SDK-init
+performance changes on a real device in a **stable, reproducible** way. Not run in CI.
+
+## What it measures
+
+`SentryStartupBenchmark` runs a cold start and reports **`timeToInitialDisplay`**
+(`StartupTimingMetric`) per iteration — the whole app cold start, taken from framework trace
+events. No trace markers are required in the SDK or the app.
+
+The flip side of marker-free measurement: an SDK change has to be large enough (roughly tens of
+milliseconds) to show above cold-start noise. Sub-millisecond changes are not resolvable with
+`timeToInitialDisplay` alone; for those, capture a perfetto trace and inspect the relevant slices
+directly (each iteration's trace is saved under
+`build/outputs/connected_android_test_additional_output/`).
+
+`CompilationMode.Full()` pins ART AOT so dexopt state can't drift between runs. `StartupMode.COLD`
+does the correct force-stop sequencing (it does **not** `pm clear`, so app data/permissions are
+kept). Iterations are capped at 12 because back-to-back cold starts thermally throttle an
+unlocked-clock device after ~14 iterations, inflating the tail of longer runs.
+
+## Running
+
+Connect a device, then:
+
+```bash
+./gradlew :sentry-android-integration-tests:sentry-uitest-android-macrobenchmark:connectedBenchmarkAndroidTest
+```
+
+Results print to the console and are written to
+`build/outputs/connected_android_test_additional_output/.../*-benchmarkData.json`.
+
+### Device hygiene (do this for trustworthy numbers)
+
+- **Wake and unlock the device first** — the launch check fails with "Unable to confirm activity
+  launch completion" on a dozing/locked screen
+  (`adb shell input keyevent KEYCODE_WAKEUP && adb shell wm dismiss-keyguard`).
+- **Charge above 25%** — Macrobenchmark refuses to run below that.
+- **Lock CPU clocks** if the device is rooted: this is the single biggest cure for thermal drift.
+- Otherwise: let the device cool between runs, keep it on AC power, enable airplane mode, and turn
+  animations off (`adb shell settings put global window_animation_scale 0`, plus
+  `transition_animation_scale` and `animator_duration_scale`).
+- Heed Macrobenchmark's warnings about unlocked clocks / low battery — they mean the numbers are
+  noisy.
+
+## A/B-ing an SDK change
+
+Macrobenchmark measures one build per run, so compare separate runs — but **interleave them**:
+running all of variant A followed by all of variant B lets thermal drift systematically penalize
+whichever variant runs second. Instead, alternate A/B rounds (build variant A, run, build variant
+B, run, repeat 2–3 times), keep each round's `*-benchmarkData.json`, and compare the
+`timeToInitialDisplay` values pooled per variant.
diff --git a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/build.gradle.kts
new file mode 100644
index 00000000000..2d2aab48a1b
--- /dev/null
+++ b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/build.gradle.kts
@@ -0,0 +1,46 @@
+plugins {
+  id("com.android.test")
+  alias(libs.plugins.kotlin.android)
+}
+
+android {
+  namespace = "io.sentry.uitest.android.macrobenchmark"
+  compileSdk = libs.versions.compileSdk.get().toInt()
+
+  defaultConfig {
+    // Macrobenchmark requires API 23+.
+    minSdk = 24
+    targetSdk = libs.versions.targetSdk.get().toInt()
+    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+  }
+
+  buildTypes {
+    // Pairs with the app's release build via matchingFallbacks. The test APK itself must be
+    // debuggable (to instrument) and signed (to install); only the target app needs to be
+    // genuinely release-like.
+    create("benchmark") {
+      isDebuggable = true
+      signingConfig = signingConfigs.getByName("debug")
+      matchingFallbacks += listOf("release")
+    }
+  }
+
+  compileOptions {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+  }
+
+  kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11 }
+
+  targetProjectPath = ":sentry-samples:sentry-samples-android"
+  // Run the test in its own process so it measures the target app cold, not itself.
+  experimentalProperties["android.experimental.self-instrumenting"] = true
+}
+
+// Benchmarks only make sense against the release build; drop the debug variant entirely.
+androidComponents { beforeVariants(selector().withBuildType("debug")) { it.enable = false } }
+
+dependencies {
+  implementation(libs.androidx.test.ext.junit)
+  implementation(libs.androidx.benchmark.macro.junit4)
+}
diff --git a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/AndroidManifest.xml b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/AndroidManifest.xml
new file mode 100644
index 00000000000..b2d3ea12352
--- /dev/null
+++ b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/AndroidManifest.xml
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />
diff --git a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/java/io/sentry/uitest/android/macrobenchmark/SentryStartupBenchmark.kt b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/java/io/sentry/uitest/android/macrobenchmark/SentryStartupBenchmark.kt
new file mode 100644
index 00000000000..24b8707ba5d
--- /dev/null
+++ b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/java/io/sentry/uitest/android/macrobenchmark/SentryStartupBenchmark.kt
@@ -0,0 +1,48 @@
+package io.sentry.uitest.android.macrobenchmark
+
+import androidx.benchmark.macro.CompilationMode
+import androidx.benchmark.macro.StartupMode
+import androidx.benchmark.macro.StartupTimingMetric
+import androidx.benchmark.macro.junit4.MacrobenchmarkRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Cold-start benchmark for the sentry-samples-android app, used to evaluate SDK-init changes on a
+ * real device in a stable, repeatable way.
+ *
+ * Reports timeToInitialDisplay ([StartupTimingMetric]) per iteration. This measures the whole app
+ * cold start from framework trace events, with no trace markers in the SDK or the app — which also
+ * means SDK changes need to be large enough (roughly tens of milliseconds) to show above cold-start
+ * noise.
+ *
+ * [CompilationMode.Full] pins ART AOT compilation so dexopt state does not drift between runs.
+ * Iterations are capped at 12: on an unthrottled Pixel 3, back-to-back cold starts hit thermal
+ * throttling after ~14 iterations, which inflates the tail of longer runs. This is NOT a CI test;
+ * it requires a connected device. To A/B an SDK change, see README.md (build the app twice, once
+ * per SDK variant, in interleaved rounds).
+ */
+@RunWith(AndroidJUnit4::class)
+class SentryStartupBenchmark {
+
+  @get:Rule val benchmarkRule = MacrobenchmarkRule()
+
+  @Test
+  fun startupFullCompilation() =
+    benchmarkRule.measureRepeated(
+      packageName = TARGET_PACKAGE,
+      metrics = listOf(StartupTimingMetric()),
+      compilationMode = CompilationMode.Full(),
+      startupMode = StartupMode.COLD,
+      iterations = 12,
+      setupBlock = { pressHome() },
+    ) {
+      startActivityAndWait()
+    }
+
+  private companion object {
+    const val TARGET_PACKAGE = "io.sentry.samples.android"
+  }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index d72087fbfa5..61f4df5b8d9 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -31,6 +31,12 @@
     android:theme="@style/AppTheme"
     tools:ignore="GoogleAppIndexingWarning, UnusedAttribute">
 
+    <!-- Allows Macrobenchmark (and `am profile`) to profile non-debuggable release/benchmark
+         builds. Harmless in debug; required for the benchmark build type. -->
+    <profileable
+      android:shell="true"
+      tools:targetApi="29" />
+
     <service
       android:name=".DummyService"
       android:enabled="true"
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 51dd84abb4f..2b3401d77ca 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -125,6 +125,7 @@ include(
     "sentry-samples:sentry-samples-netflix-dgs",
     "sentry-android-integration-tests:sentry-uitest-android-critical",
     "sentry-android-integration-tests:sentry-uitest-android-benchmark",
+    "sentry-android-integration-tests:sentry-uitest-android-macrobenchmark",
     "sentry-android-integration-tests:sentry-uitest-android",
     "sentry-android-integration-tests:test-app-plain",
     "sentry-android-integration-tests:test-app-sentry",

From 34c912af8ac0b9def83ad0dbfe8d1452d460c7ed Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 3 Jul 2026 10:25:32 +0200
Subject: [PATCH 263/391] chore(deps): bump the github-actions group across 1
 directory with 6 updates (#5695)

Bumps the github-actions group with 6 updates in the / directory:

| Package | From | To |
| --- | --- | --- |
| [actions/cache](https://github.com/actions/cache) | `6.0.0` | `6.1.0` |
| [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) | `2.26.12` | `2.26.14` |
| [dorny/paths-filter](https://github.com/dorny/paths-filter) | `4.0.1` | `4.0.2` |
| [github/codeql-action/init](https://github.com/github/codeql-action) | `4.36.2` | `4.36.3` |
| [github/codeql-action/analyze](https://github.com/github/codeql-action) | `4.36.2` | `4.36.3` |
| [getsentry/craft](https://github.com/getsentry/craft) | `2.26.12` | `2.26.14` |



Updates `actions/cache` from 6.0.0 to 6.1.0
- [Release notes](https://github.com/actions/cache/releases)
- [Changelog](https://github.com/actions/cache/blob/main/RELEASES.md)
- [Commits](https://github.com/actions/cache/compare/2c8a9bd7457de244a408f35966fab2fb45fda9c8...55cc8345863c7cc4c66a329aec7e433d2d1c52a9)

Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.26.12 to 2.26.14
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/9312e4dfc82e545ef0cad911c23f430fe5f52673...cdb657d4bbc70cd497876ad158984b4d345a48ae)

Updates `dorny/paths-filter` from 4.0.1 to 4.0.2
- [Release notes](https://github.com/dorny/paths-filter/releases)
- [Changelog](https://github.com/dorny/paths-filter/blob/master/CHANGELOG.md)
- [Commits](https://github.com/dorny/paths-filter/compare/fbd0ab8f3e69293af611ebaee6363fc25e6d187d...7b450fff21473bca461d4b92ce414b9d0420d706)

Updates `github/codeql-action/init` from 4.36.2 to 4.36.3
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/8aad20d150bbac5944a9f9d289da16a4b0d87c1e...54f647b7e1bb85c95cddabcd46b0c578ec92bc1a)

Updates `github/codeql-action/analyze` from 4.36.2 to 4.36.3
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/8aad20d150bbac5944a9f9d289da16a4b0d87c1e...54f647b7e1bb85c95cddabcd46b0c578ec92bc1a)

Updates `getsentry/craft` from 2.26.12 to 2.26.14
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/9312e4dfc82e545ef0cad911c23f430fe5f52673...cdb657d4bbc70cd497876ad158984b4d345a48ae)

---
updated-dependencies:
- dependency-name: actions/cache
  dependency-version: 6.1.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.26.14
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: dorny/paths-filter
  dependency-version: 4.0.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/init
  dependency-version: 4.36.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.36.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: getsentry/craft
  dependency-version: 2.26.14
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/changelog-preview.yml             | 2 +-
 .github/workflows/changes-in-high-risk-code.yml     | 2 +-
 .github/workflows/codeql-analysis.yml               | 4 ++--
 .github/workflows/integration-tests-benchmarks.yml  | 2 +-
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 .github/workflows/release.yml                       | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 12 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index d196d595d73..e6f2a560d21 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -50,7 +50,7 @@ jobs:
           sudo udevadm trigger --name-match=kvm
 
       - name: AVD cache
-        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         id: avd-cache
         with:
           path: |
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 57106c8e05a..2bb7f3191d7 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -32,7 +32,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index 3e510787ce2..27f1d0006e4 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@9312e4dfc82e545ef0cad911c23f430fe5f52673 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@cdb657d4bbc70cd497876ad158984b4d345a48ae # v2
     secrets: inherit
diff --git a/.github/workflows/changes-in-high-risk-code.yml b/.github/workflows/changes-in-high-risk-code.yml
index 78918167207..864be8140ad 100644
--- a/.github/workflows/changes-in-high-risk-code.yml
+++ b/.github/workflows/changes-in-high-risk-code.yml
@@ -19,7 +19,7 @@ jobs:
       - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Get changed files
         id: changes
-        uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
+        uses: dorny/paths-filter@7b450fff21473bca461d4b92ce414b9d0420d706 # v4.0.2
         with:
           token: ${{ github.token }}
           filters: .github/file-filters.yml
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index c3cad17b1a9..2335ef3e0a9 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # pin@v2
+        uses: github/codeql-action/init@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # pin@v2
+        uses: github/codeql-action/analyze@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # pin@v2
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index fa025030e8a..7780cf63e02 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -92,7 +92,7 @@ jobs:
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
-      - uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
+      - uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         id: app-plain-cache
         with:
           path: sentry-android-integration-tests/test-app-plain/build/outputs/apk/release/test-app-plain-release.apk
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index d67237d7089..f79f36618d1 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -30,7 +30,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index bd4a9058ddc..e5d4f2c65dd 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -86,7 +86,7 @@ jobs:
           sudo udevadm trigger --name-match=kvm
 
       - name: AVD cache
-        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         id: avd-cache
         with:
           path: |
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 807236d4ed2..51e9987cc19 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@9312e4dfc82e545ef0cad911c23f430fe5f52673 # v2
+        uses: getsentry/craft@cdb657d4bbc70cd497876ad158984b4d345a48ae # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index cf69a869def..fec0d2a5a7c 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -52,7 +52,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 2a94987549c..a86600b30d3 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -52,7 +52,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index b5516e17453..799e93fd293 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -52,7 +52,7 @@ jobs:
 
       # Workaround for https://github.com/gradle/actions/issues/21 to use config cache
       - name: Cache buildSrc
-        uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8 # v6.0.0
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         with:
           path: buildSrc/build
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}

From 83277d1441dc432f7bd542b19fcb0d3725eb97a2 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 3 Jul 2026 13:19:42 +0200
Subject: [PATCH 264/391] fix(android): Name the device-info caching thread
 (#5684)

* fix(android): Name the device-info caching thread

DefaultAndroidEventProcessor created its device-info pre-caching
executor via Executors.newSingleThreadExecutor() with no ThreadFactory,
so the JDK named the thread pool-N-thread-M and it was not identifiable
as an SDK thread. Supply a ThreadFactory that names it
SentryDeviceInfoCache, matching the convention used elsewhere in the SDK.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                        |  6 ++++++
 .../android/core/DefaultAndroidEventProcessor.java  | 13 ++++++++++++-
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3a290e2b3e9..68ba41d95eb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Name the device-info caching thread `SentryDeviceInfoCache` so all threads spawned by the SDK are identifiable ([#5684](https://github.com/getsentry/sentry-java/pull/5684))
+
 ## 8.47.0
 
 ### Behavioral Changes
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java
index 7671935bb05..83f892573e4 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/DefaultAndroidEventProcessor.java
@@ -27,6 +27,7 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ThreadFactory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
@@ -56,7 +57,8 @@ public DefaultAndroidEventProcessor(
     // noinspection Convert2MethodRef
     // some device info performs disk I/O, but it's result is cached, let's pre-cache it
     @Nullable Future<DeviceInfoUtil> deviceInfoUtil;
-    final @NotNull ExecutorService executorService = Executors.newSingleThreadExecutor();
+    final @NotNull ExecutorService executorService =
+        Executors.newSingleThreadExecutor(new DeviceInfoCacheThreadFactory());
     try {
       deviceInfoUtil =
           executorService.submit(() -> DeviceInfoUtil.getInstance(this.context, options));
@@ -425,4 +427,13 @@ private void setSideLoadedInfo(final @NotNull SentryBaseEvent event) {
   public @Nullable Long getOrder() {
     return 8000L;
   }
+
+  private static final class DeviceInfoCacheThreadFactory implements ThreadFactory {
+    @Override
+    public @NotNull Thread newThread(final @NotNull Runnable r) {
+      final Thread ret = new Thread(r, "SentryDeviceInfoCache");
+      ret.setDaemon(true);
+      return ret;
+    }
+  }
 }

From 2ad4e0dfc7b8138bbce76e521555dbc1ccacdd0e Mon Sep 17 00:00:00 2001
From: tsushanth <78000697+tsushanth@users.noreply.github.com>
Date: Fri, 3 Jul 2026 05:06:37 -0700
Subject: [PATCH 265/391] feat: add trace_metric_byte to DataCategory enum
 (#5626)

* feat: add trace_metric_byte to DataCategory enum

* chore: regenerate API dump with TraceMetricByte in DataCategory

* feat: record TraceMetricByte in client reports when trace metrics are discarded

Mirrors the LogByte pattern: records byte-level data category alongside the
item-level one when trace metrics are dropped by beforeSendMetrics, queue
overflow, or envelope discard.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* changelog: add trace_metric_byte data category entry

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore: apply spotless formatting

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                           |  4 ++++
 sentry/api/sentry.api                                  |  1 +
 sentry/src/main/java/io/sentry/DataCategory.java       |  1 +
 sentry/src/main/java/io/sentry/SentryClient.java       |  8 ++++++++
 .../io/sentry/clientreport/ClientReportRecorder.java   |  3 +++
 .../java/io/sentry/metrics/MetricsBatchProcessor.java  |  7 +++++++
 sentry/src/test/java/io/sentry/SentryClientTest.kt     | 10 ++++++++--
 .../java/io/sentry/clientreport/ClientReportTest.kt    |  3 +++
 .../io/sentry/metrics/MetricsBatchProcessorTest.kt     | 10 +++++++++-
 9 files changed, 44 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 68ba41d95eb..92cfd115361 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Features
+
+- Add `trace_metric_byte` data category and record byte-level client reports when trace metrics are discarded ([#5626](https://github.com/getsentry/sentry-java/pull/5626))
+
 ### Fixes
 
 - Name the device-info caching thread `SentryDeviceInfoCache` so all threads spawned by the SDK are identifiable ([#5684](https://github.com/getsentry/sentry-java/pull/5684))
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 383ea92b116..d62ecf41193 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -373,6 +373,7 @@ public final class io/sentry/DataCategory : java/lang/Enum {
 	public static final field Session Lio/sentry/DataCategory;
 	public static final field Span Lio/sentry/DataCategory;
 	public static final field TraceMetric Lio/sentry/DataCategory;
+	public static final field TraceMetricByte Lio/sentry/DataCategory;
 	public static final field Transaction Lio/sentry/DataCategory;
 	public static final field Unknown Lio/sentry/DataCategory;
 	public static final field UserReport Lio/sentry/DataCategory;
diff --git a/sentry/src/main/java/io/sentry/DataCategory.java b/sentry/src/main/java/io/sentry/DataCategory.java
index 3702fd713a1..b34388859e2 100644
--- a/sentry/src/main/java/io/sentry/DataCategory.java
+++ b/sentry/src/main/java/io/sentry/DataCategory.java
@@ -12,6 +12,7 @@ public enum DataCategory {
   LogItem("log_item"),
   LogByte("log_byte"),
   TraceMetric("trace_metric"),
+  TraceMetricByte("trace_metric_byte"),
   Monitor("monitor"),
   Profile("profile"),
   ProfileChunkUi("profile_chunk_ui"),
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index a739eddd9d9..4210e2994a7 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -1336,6 +1336,7 @@ public void captureMetric(
     }
 
     if (metricsEvent != null) {
+      final @NotNull SentryMetricsEvent tmpMetricsEvent = metricsEvent;
       metricsEvent = executeBeforeSendMetric(metricsEvent, hint);
 
       if (metricsEvent == null) {
@@ -1345,6 +1346,13 @@ public void captureMetric(
         options
             .getClientReportRecorder()
             .recordLostEvent(DiscardReason.BEFORE_SEND, DataCategory.TraceMetric);
+        final long metricsEventNumberOfBytes =
+            JsonSerializationUtils.byteSizeOf(
+                options.getSerializer(), options.getLogger(), tmpMetricsEvent);
+        options
+            .getClientReportRecorder()
+            .recordLostEvent(
+                DiscardReason.BEFORE_SEND, DataCategory.TraceMetricByte, metricsEventNumberOfBytes);
         return;
       }
 
diff --git a/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java b/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
index 0180b16977d..b3756ed32e4 100644
--- a/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
+++ b/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
@@ -124,6 +124,9 @@ public void recordLostEnvelopeItem(
             final @NotNull List<SentryMetricsEvent> items = metrics.getItems();
             final long count = items.size();
             recordLostEventInternal(reason.getReason(), itemCategory.getCategory(), count);
+            final long metricBytes = envelopeItem.getData().length;
+            recordLostEventInternal(
+                reason.getReason(), DataCategory.TraceMetricByte.getCategory(), metricBytes);
             executeOnDiscard(reason, itemCategory, count);
           } else {
             options
diff --git a/sentry/src/main/java/io/sentry/metrics/MetricsBatchProcessor.java b/sentry/src/main/java/io/sentry/metrics/MetricsBatchProcessor.java
index 169f36b973b..2d5c78e5e89 100644
--- a/sentry/src/main/java/io/sentry/metrics/MetricsBatchProcessor.java
+++ b/sentry/src/main/java/io/sentry/metrics/MetricsBatchProcessor.java
@@ -13,6 +13,7 @@
 import io.sentry.clientreport.DiscardReason;
 import io.sentry.transport.ReusableCountLatch;
 import io.sentry.util.AutoClosableReentrantLock;
+import io.sentry.util.JsonSerializationUtils;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Queue;
@@ -58,6 +59,12 @@ public void add(final @NotNull SentryMetricsEvent metricsEvent) {
       options
           .getClientReportRecorder()
           .recordLostEvent(DiscardReason.QUEUE_OVERFLOW, DataCategory.TraceMetric);
+      final long lostBytes =
+          JsonSerializationUtils.byteSizeOf(
+              options.getSerializer(), options.getLogger(), metricsEvent);
+      options
+          .getClientReportRecorder()
+          .recordLostEvent(DiscardReason.QUEUE_OVERFLOW, DataCategory.TraceMetricByte, lostBytes);
       return;
     }
     pendingCount.increment();
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index f51345957e4..7ef8967de2b 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -388,7 +388,10 @@ class SentryClientTest {
 
     assertClientReport(
       fixture.sentryOptions.clientReportRecorder,
-      listOf(DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetric.category, 1)),
+      listOf(
+        DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetric.category, 1),
+        DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetricByte.category, 120),
+      ),
     )
   }
 
@@ -408,7 +411,10 @@ class SentryClientTest {
 
     assertClientReport(
       fixture.sentryOptions.clientReportRecorder,
-      listOf(DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetric.category, 1)),
+      listOf(
+        DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetric.category, 1),
+        DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetricByte.category, 120),
+      ),
     )
   }
 
diff --git a/sentry/src/test/java/io/sentry/clientreport/ClientReportTest.kt b/sentry/src/test/java/io/sentry/clientreport/ClientReportTest.kt
index 95639d8c581..ceb254213cb 100644
--- a/sentry/src/test/java/io/sentry/clientreport/ClientReportTest.kt
+++ b/sentry/src/test/java/io/sentry/clientreport/ClientReportTest.kt
@@ -412,6 +412,9 @@ class ClientReportTest {
     val metricItem =
       clientReport!!.discardedEvents!!.first { it.category == DataCategory.TraceMetric.category }
     assertEquals(3, metricItem.quantity)
+    val metricByteItem =
+      clientReport.discardedEvents!!.first { it.category == DataCategory.TraceMetricByte.category }
+    assertEquals(envelope.items.first().data.size.toLong(), metricByteItem.quantity)
   }
 
   private fun givenClientReportRecorder(
diff --git a/sentry/src/test/java/io/sentry/metrics/MetricsBatchProcessorTest.kt b/sentry/src/test/java/io/sentry/metrics/MetricsBatchProcessorTest.kt
index da83ad882f6..5ca1d0fe87a 100644
--- a/sentry/src/test/java/io/sentry/metrics/MetricsBatchProcessorTest.kt
+++ b/sentry/src/test/java/io/sentry/metrics/MetricsBatchProcessorTest.kt
@@ -12,6 +12,7 @@ import io.sentry.clientreport.DiscardedEvent
 import io.sentry.protocol.SentryId
 import io.sentry.test.DeferredExecutorService
 import io.sentry.test.injectForField
+import io.sentry.util.JsonSerializationUtils
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -80,9 +81,16 @@ class MetricsBatchProcessorTest {
     processor.add(droppedMetricsEvent)
 
     // verify that a client report was recorded for the dropped metrics item
+    val droppedBytes =
+      JsonSerializationUtils.byteSizeOf(options.serializer, options.logger, droppedMetricsEvent)
     val expectedEvents =
       mutableListOf(
-        DiscardedEvent(DiscardReason.QUEUE_OVERFLOW.reason, DataCategory.TraceMetric.category, 1)
+        DiscardedEvent(DiscardReason.QUEUE_OVERFLOW.reason, DataCategory.TraceMetric.category, 1),
+        DiscardedEvent(
+          DiscardReason.QUEUE_OVERFLOW.reason,
+          DataCategory.TraceMetricByte.category,
+          droppedBytes,
+        ),
       )
 
     ClientReportTestHelper.assertClientReport(options.clientReportRecorder, expectedEvents)

From 8a76183f3285ccba7be147e28bf0e5b2d276de23 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Fri, 3 Jul 2026 15:24:51 +0200
Subject: [PATCH 266/391] fix(core): Apply byte category rate limits (#5716)

* feat: add trace_metric_byte to DataCategory enum

* chore: regenerate API dump with TraceMetricByte in DataCategory

* feat: record TraceMetricByte in client reports when trace metrics are discarded

Mirrors the LogByte pattern: records byte-level data category alongside the
item-level one when trace metrics are dropped by beforeSendMetrics, queue
overflow, or envelope discard.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* changelog: add trace_metric_byte data category entry

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(core): Apply byte category rate limits

* changelog

* Format code

---------

Co-authored-by: tsushanth <78000697+tsushanth@users.noreply.github.com>
Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |  1 +
 .../java/io/sentry/transport/RateLimiter.java |  4 +-
 .../io/sentry/transport/RateLimiterTest.kt    | 52 +++++++++++++++++++
 3 files changed, 55 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 92cfd115361..a00df9a2904 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@
 ### Fixes
 
 - Name the device-info caching thread `SentryDeviceInfoCache` so all threads spawned by the SDK are identifiable ([#5684](https://github.com/getsentry/sentry-java/pull/5684))
+- Apply byte-category rate limits to log and trace metric envelope items ([#5716](https://github.com/getsentry/sentry-java/pull/5716))
 
 ## 8.47.0
 
diff --git a/sentry/src/main/java/io/sentry/transport/RateLimiter.java b/sentry/src/main/java/io/sentry/transport/RateLimiter.java
index 549a794db90..a0cd96abba9 100644
--- a/sentry/src/main/java/io/sentry/transport/RateLimiter.java
+++ b/sentry/src/main/java/io/sentry/transport/RateLimiter.java
@@ -212,11 +212,11 @@ private boolean isRetryAfter(final @NotNull String itemType) {
       case "feedback":
         return Collections.singletonList(DataCategory.Feedback);
       case "log":
-        return Collections.singletonList(DataCategory.LogItem);
+        return Arrays.asList(DataCategory.LogItem, DataCategory.LogByte);
       case "span":
         return Collections.singletonList(DataCategory.Span);
       case "trace_metric":
-        return Collections.singletonList(DataCategory.TraceMetric);
+        return Arrays.asList(DataCategory.TraceMetric, DataCategory.TraceMetricByte);
       default:
         return Collections.singletonList(DataCategory.Unknown);
     }
diff --git a/sentry/src/test/java/io/sentry/transport/RateLimiterTest.kt b/sentry/src/test/java/io/sentry/transport/RateLimiterTest.kt
index b3a20ddde76..33cda17106f 100644
--- a/sentry/src/test/java/io/sentry/transport/RateLimiterTest.kt
+++ b/sentry/src/test/java/io/sentry/transport/RateLimiterTest.kt
@@ -457,6 +457,31 @@ class RateLimiterTest {
     verifyNoMoreInteractions(fixture.clientReportRecorder)
   }
 
+  @Test
+  fun `drop log items as lost when log byte is rate limited`() {
+    val rateLimiter = fixture.getSUT()
+    val scopes = mock<IScopes>()
+    whenever(scopes.options).thenReturn(SentryOptions())
+
+    val logEventItem =
+      SentryEnvelopeItem.fromLogs(
+        fixture.serializer,
+        SentryLogEvents(
+          listOf(SentryLogEvent(SentryId(), SentryLongDate(0), "hello", SentryLogLevel.INFO))
+        ),
+      )
+    val envelope = SentryEnvelope(SentryEnvelopeHeader(null), arrayListOf(logEventItem))
+
+    rateLimiter.updateRetryAfterLimits("60:log_byte:key", null, 1)
+    val result = rateLimiter.filter(envelope, Hint())
+
+    assertNull(result)
+
+    verify(fixture.clientReportRecorder, times(1))
+      .recordLostEnvelopeItem(eq(DiscardReason.RATELIMIT_BACKOFF), same(logEventItem))
+    verifyNoMoreInteractions(fixture.clientReportRecorder)
+  }
+
   @Test
   fun `drop profileChunkUi items as lost`() {
     val rateLimiter = fixture.getSUT()
@@ -590,6 +615,33 @@ class RateLimiterTest {
     verifyNoMoreInteractions(fixture.clientReportRecorder)
   }
 
+  @Test
+  fun `drop trace metric items as lost when trace metric byte is rate limited`() {
+    val rateLimiter = fixture.getSUT()
+
+    // There is no span API yet so we'll create the envelope manually using EnvelopeReader
+    // This mimics how hybrid SDKs would send trace_metric envelope items
+    val spanPayload = """{"items":[]}"""
+    val metricItemHeader =
+      """{"type":"trace_metric","length":${spanPayload.length},"content_type":"application/vnd.sentry.items.trace-metric+json","item_count":1}"""
+    val envelopeHeader = """{}"""
+    val rawEnvelope = "$envelopeHeader\n$metricItemHeader\n$spanPayload"
+
+    val options = SentryOptions()
+    val envelopeReader = EnvelopeReader(JsonSerializer(options))
+    val metricEnvelope = envelopeReader.read(rawEnvelope.byteInputStream())!!
+    val metricItem = metricEnvelope.items.first()
+
+    rateLimiter.updateRetryAfterLimits("60:trace_metric_byte:key", null, 1)
+    val result = rateLimiter.filter(metricEnvelope, Hint())
+
+    assertNull(result)
+
+    verify(fixture.clientReportRecorder, times(1))
+      .recordLostEnvelopeItem(eq(DiscardReason.RATELIMIT_BACKOFF), same(metricItem))
+    verifyNoMoreInteractions(fixture.clientReportRecorder)
+  }
+
   @Test
   fun `apply rate limits notifies observers`() {
     val rateLimiter = fixture.getSUT()

From 44d18f56b41c98a11883a40899745a8af3960284 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Fri, 3 Jul 2026 15:25:24 +0200
Subject: [PATCH 267/391] fix(core): Record byte discards for event processor
 drops (#5718)

* fix(core): Record byte discards for event processor drops

Track log and trace metric byte counts when event processors drop log or metric events. This keeps EventProcessor discard accounting aligned with before-send and queue-overflow paths.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../src/main/java/io/sentry/SentryClient.java | 18 +++++
 .../test/java/io/sentry/SentryClientTest.kt   | 67 +++++++++++++++++++
 3 files changed, 86 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a00df9a2904..ba2004921a2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
 
 ### Fixes
 
+- Record byte-level client reports when event processors discard logs or trace metrics ([#5718](https://github.com/getsentry/sentry-java/pull/5718))
 - Name the device-info caching thread `SentryDeviceInfoCache` so all threads spawned by the SDK are identifiable ([#5684](https://github.com/getsentry/sentry-java/pull/5684))
 - Apply byte-category rate limits to log and trace metric envelope items ([#5716](https://github.com/getsentry/sentry-java/pull/5716))
 
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index 4210e2994a7..02934b1ed7d 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -511,6 +511,7 @@ private SentryEvent processEvent(
   private SentryLogEvent processLogEvent(
       @NotNull SentryLogEvent event, final @NotNull List<EventProcessor> eventProcessors) {
     for (final EventProcessor processor : eventProcessors) {
+      final @NotNull SentryLogEvent eventBeforeProcessor = event;
       try {
         event = processor.process(event);
       } catch (Throwable e) {
@@ -533,6 +534,13 @@ private SentryLogEvent processLogEvent(
         options
             .getClientReportRecorder()
             .recordLostEvent(DiscardReason.EVENT_PROCESSOR, DataCategory.LogItem);
+        final long logEventNumberOfBytes =
+            JsonSerializationUtils.byteSizeOf(
+                options.getSerializer(), options.getLogger(), eventBeforeProcessor);
+        options
+            .getClientReportRecorder()
+            .recordLostEvent(
+                DiscardReason.EVENT_PROCESSOR, DataCategory.LogByte, logEventNumberOfBytes);
         break;
       }
     }
@@ -545,6 +553,7 @@ private SentryMetricsEvent processMetricsEvent(
       final @NotNull List<EventProcessor> eventProcessors,
       final @NotNull Hint hint) {
     for (final EventProcessor processor : eventProcessors) {
+      final @NotNull SentryMetricsEvent eventBeforeProcessor = event;
       try {
         event = processor.process(event, hint);
       } catch (Throwable e) {
@@ -567,6 +576,15 @@ private SentryMetricsEvent processMetricsEvent(
         options
             .getClientReportRecorder()
             .recordLostEvent(DiscardReason.EVENT_PROCESSOR, DataCategory.TraceMetric);
+        final long metricsEventNumberOfBytes =
+            JsonSerializationUtils.byteSizeOf(
+                options.getSerializer(), options.getLogger(), eventBeforeProcessor);
+        options
+            .getClientReportRecorder()
+            .recordLostEvent(
+                DiscardReason.EVENT_PROCESSOR,
+                DataCategory.TraceMetricByte,
+                metricsEventNumberOfBytes);
         break;
       }
     }
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index 7ef8967de2b..5b407bfef3d 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -33,6 +33,7 @@ import io.sentry.test.injectForField
 import io.sentry.transport.ITransport
 import io.sentry.transport.ITransportGate
 import io.sentry.util.HintUtils
+import io.sentry.util.JsonSerializationUtils
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 import java.io.File
@@ -341,6 +342,39 @@ class SentryClientTest {
     )
   }
 
+  @Test
+  fun `when log is dropped by event processor, log byte discard is recorded`() {
+    val scope = createScope()
+    val logEvent = SentryLogEvent(SentryId(), SentryNanotimeDate(), "message", SentryLogLevel.WARN)
+    val logEventNumberOfBytes =
+      JsonSerializationUtils.byteSizeOf(
+        fixture.sentryOptions.serializer,
+        fixture.sentryOptions.logger,
+        logEvent,
+      )
+    scope.addEventProcessor(
+      object : EventProcessor {
+        override fun process(event: SentryLogEvent): SentryLogEvent? = null
+      }
+    )
+
+    val sut = fixture.getSut()
+    sut.captureLog(logEvent, scope)
+
+    verify(fixture.loggerBatchProcessor, never()).add(any())
+    assertClientReport(
+      fixture.sentryOptions.clientReportRecorder,
+      listOf(
+        DiscardedEvent(DiscardReason.EVENT_PROCESSOR.reason, DataCategory.LogItem.category, 1),
+        DiscardedEvent(
+          DiscardReason.EVENT_PROCESSOR.reason,
+          DataCategory.LogByte.category,
+          logEventNumberOfBytes,
+        ),
+      ),
+    )
+  }
+
   @Test
   fun `when beforeSendLog is returns new instance, new instance is sent`() {
     val scope = createScope()
@@ -418,6 +452,39 @@ class SentryClientTest {
     )
   }
 
+  @Test
+  fun `when metric is dropped by event processor, metric byte discard is recorded`() {
+    val scope = createScope()
+    val metricsEvent = SentryMetricsEvent(SentryId(), SentryNanotimeDate(), "name", "gauge", 123.0)
+    val metricsEventNumberOfBytes =
+      JsonSerializationUtils.byteSizeOf(
+        fixture.sentryOptions.serializer,
+        fixture.sentryOptions.logger,
+        metricsEvent,
+      )
+    scope.addEventProcessor(
+      object : EventProcessor {
+        override fun process(event: SentryMetricsEvent, hint: Hint): SentryMetricsEvent? = null
+      }
+    )
+
+    val sut = fixture.getSut()
+    sut.captureMetric(metricsEvent, scope, null)
+
+    verify(fixture.metricsBatchProcessor, never()).add(any())
+    assertClientReport(
+      fixture.sentryOptions.clientReportRecorder,
+      listOf(
+        DiscardedEvent(DiscardReason.EVENT_PROCESSOR.reason, DataCategory.TraceMetric.category, 1),
+        DiscardedEvent(
+          DiscardReason.EVENT_PROCESSOR.reason,
+          DataCategory.TraceMetricByte.category,
+          metricsEventNumberOfBytes,
+        ),
+      ),
+    )
+  }
+
   @Test
   fun `when beforeSendMetric is returns new instance, new instance is sent`() {
     val scope = createScope()

From 066c6cac3ec0d6e1d191752727eaacb527ed2ff1 Mon Sep 17 00:00:00 2001
From: Stefan Jandl <reg@bitfox.at>
Date: Mon, 6 Jul 2026 12:01:52 +0200
Subject: [PATCH 268/391] feat: added `report historic tombstones` option to
 the manifest reader (#5683)

---
 CHANGELOG.md                                  |  1 +
 .../android/core/ManifestMetadataReader.java  |  7 +++
 .../core/ManifestMetadataReaderTest.kt        | 50 +++++++++++++++++++
 3 files changed, 58 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ba2004921a2..e082da5f172 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Features
 
 - Add `trace_metric_byte` data category and record byte-level client reports when trace metrics are discarded ([#5626](https://github.com/getsentry/sentry-java/pull/5626))
+- Support the `io.sentry.tombstone.report-historical` manifest option to enable historical tombstone reporting via `AndroidManifest.xml` `<meta-data>` ([#5683](https://github.com/getsentry/sentry-java/pull/5683))
 
 ### Fixes
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index c34ee0dbfa9..6ae9be3e8b0 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -37,6 +37,7 @@ final class ManifestMetadataReader {
 
   static final String TOMBSTONE_ENABLE = "io.sentry.tombstone.enable";
   static final String TOMBSTONE_ATTACH_RAW = "io.sentry.tombstone.attach-raw";
+  static final String TOMBSTONE_REPORT_HISTORICAL = "io.sentry.tombstone.report-historical";
 
   static final String AUTO_INIT = "io.sentry.auto-init";
   static final String NDK_ENABLE = "io.sentry.ndk.enable";
@@ -232,6 +233,12 @@ static void applyMetadata(
             readBool(metadata, logger, TOMBSTONE_ENABLE, options.isTombstoneEnabled()));
         options.setAttachRawTombstone(
             readBool(metadata, logger, TOMBSTONE_ATTACH_RAW, options.isAttachRawTombstone()));
+        options.setReportHistoricalTombstones(
+            readBool(
+                metadata,
+                logger,
+                TOMBSTONE_REPORT_HISTORICAL,
+                options.isReportHistoricalTombstones()));
 
         // use enableAutoSessionTracking as fallback
         options.setEnableAutoSessionTracking(
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index 3b12e6489a7..94da78fcfaa 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -313,6 +313,56 @@ class ManifestMetadataReaderTest {
     assertEquals(false, fixture.options.isAttachRawTombstone)
   }
 
+  @Test
+  fun `applyMetadata reads tombstone enable to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.TOMBSTONE_ENABLE to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(true, fixture.options.isTombstoneEnabled)
+  }
+
+  @Test
+  fun `applyMetadata reads tombstone enable to options and keeps default`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(false, fixture.options.isTombstoneEnabled)
+  }
+
+  @Test
+  fun `applyMetadata reads tombstone report historical to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.TOMBSTONE_REPORT_HISTORICAL to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(true, fixture.options.isReportHistoricalTombstones)
+  }
+
+  @Test
+  fun `applyMetadata reads tombstone report historical to options and keeps default`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(false, fixture.options.isReportHistoricalTombstones)
+  }
+
   @Test
   fun `applyMetadata reads anr report historical to options`() {
     // Arrange

From 613407547afec7a45380ba3f0bc6f9902abca998 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 6 Jul 2026 14:17:39 +0200
Subject: [PATCH 269/391] feat(samples): Make Android error buttons
 identifiable in Sentry (#5722)

Every button on the sample app's Errors tab sent generic, indistinguishable
events (e.g. two buttons both threw "Uncaught Exception from Java." and "Send
Message" sent "Some message."), so there was no way to tell which button
produced which event in Sentry.

Each Errors button now tags its event with sample_action=<button key> (reusing
the existing SentryTraced keys) and uses distinctive text that names the button.
Buttons whose crash carries no message (stack overflow, OOM, native) are still
identifiable via the tag. The native captured message is likewise renamed.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../src/main/cpp/native-sample.cpp            |   2 +-
 .../io/sentry/samples/android/MainActivity.kt | 101 +++++++++++++++---
 2 files changed, 88 insertions(+), 15 deletions(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/cpp/native-sample.cpp b/sentry-samples/sentry-samples-android/src/main/cpp/native-sample.cpp
index 0a7d4dbb111..abac2bf58fe 100644
--- a/sentry-samples/sentry-samples-android/src/main/cpp/native-sample.cpp
+++ b/sentry-samples/sentry-samples-android/src/main/cpp/native-sample.cpp
@@ -17,7 +17,7 @@ JNIEXPORT void JNICALL Java_io_sentry_samples_android_NativeSample_message(JNIEn
     sentry_value_t event = sentry_value_new_message_event(
             /*   level */ SENTRY_LEVEL_INFO,
             /*  logger */ "custom",
-            /* message */ "It works!"
+            /* message */ "Native Capture button: native message"
     );
     sentry_capture_event(event);
 }
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
index d53f7e4687f..9fdcaafb008 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
@@ -23,12 +23,17 @@ import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.PaddingValues
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.foundation.layout.WindowInsetsSides
 import androidx.compose.foundation.layout.defaultMinSize
 import androidx.compose.foundation.layout.fillMaxHeight
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.only
 import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.safeDrawing
 import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.windowInsetsPadding
 import androidx.compose.foundation.lazy.grid.GridCells
 import androidx.compose.foundation.lazy.grid.GridItemSpan
 import androidx.compose.foundation.lazy.grid.LazyVerticalGrid
@@ -184,11 +189,21 @@ fun MainScreen() {
 
   Surface(modifier = Modifier.fillMaxSize()) {
     Row(modifier = Modifier.fillMaxSize()) {
+      // NavigationRail already draws its background edge-to-edge (behind the status bar) while
+      // insetting its own items, so we only need to inset the content area on the remaining sides.
       CategoryNavigationRail(
         selectedCategory = selectedCategory,
         onCategorySelected = { selectedCategory = it },
       )
-      Surface(modifier = Modifier.fillMaxSize()) {
+      Surface(
+        modifier =
+          Modifier.fillMaxSize()
+            .windowInsetsPadding(
+              WindowInsets.safeDrawing.only(
+                WindowInsetsSides.Top + WindowInsetsSides.Bottom + WindowInsetsSides.End
+              )
+            )
+      ) {
         when (selectedCategory) {
           Category.ERRORS -> ErrorsScreen()
           Category.TRACING -> TracingScreen()
@@ -271,7 +286,12 @@ fun ErrorsScreen() {
   ) {
     item {
       SentryTraced("crash_from_java") {
-        OutlinedButton(onClick = { throw RuntimeException("Uncaught Exception from Java.") }) {
+        OutlinedButton(
+          onClick = {
+            tagSampleAction("crash_from_java")
+            throw RuntimeException("Crash from Java button: uncaught RuntimeException")
+          }
+        ) {
           Text("Crash from Java", maxLines = 2, overflow = TextOverflow.Ellipsis)
         }
       }
@@ -279,7 +299,12 @@ fun ErrorsScreen() {
     item {
       SentryTraced("capture_exception") {
         OutlinedButton(
-          onClick = { Sentry.captureException(Exception(Exception(Exception("Some exception.")))) },
+          onClick = {
+            tagSampleAction("capture_exception")
+            Sentry.captureException(
+              Exception(Exception(Exception("Capture Exception button: nested exception")))
+            )
+          },
           modifier = Modifier,
         ) {
           Text("Capture Exception", maxLines = 2, overflow = TextOverflow.Ellipsis)
@@ -290,11 +315,12 @@ fun ErrorsScreen() {
       SentryTraced("breadcrumb") {
         OutlinedButton(
           onClick = {
-            Sentry.addBreadcrumb("Breadcrumb")
+            tagSampleAction("breadcrumb")
+            Sentry.addBreadcrumb("Breadcrumb button clicked")
             Sentry.setExtra("extra", "extra")
             Sentry.setFingerprint(listOf("fingerprint"))
             Sentry.setTransaction("transaction")
-            Sentry.captureException(Exception("Some exception with scope."))
+            Sentry.captureException(Exception("Breadcrumb button: exception with scope data"))
           },
           modifier = Modifier,
         ) {
@@ -304,21 +330,39 @@ fun ErrorsScreen() {
     }
     item {
       SentryTraced("stack_overflow") {
-        OutlinedButton(onClick = { stackOverflow() }, modifier = Modifier) {
+        OutlinedButton(
+          onClick = {
+            tagSampleAction("stack_overflow")
+            stackOverflow()
+          },
+          modifier = Modifier,
+        ) {
           Text("Stack Overflow", maxLines = 2, overflow = TextOverflow.Ellipsis)
         }
       }
     }
     item {
       SentryTraced("native_crash") {
-        OutlinedButton(onClick = { NativeSample.crash() }, modifier = Modifier) {
+        OutlinedButton(
+          onClick = {
+            tagSampleAction("native_crash")
+            NativeSample.crash()
+          },
+          modifier = Modifier,
+        ) {
           Text("Native Crash", maxLines = 2, overflow = TextOverflow.Ellipsis)
         }
       }
     }
     item {
       SentryTraced("native_capture") {
-        OutlinedButton(onClick = { NativeSample.message() }, modifier = Modifier) {
+        OutlinedButton(
+          onClick = {
+            tagSampleAction("native_capture")
+            NativeSample.message()
+          },
+          modifier = Modifier,
+        ) {
           Text("Native Capture", maxLines = 2, overflow = TextOverflow.Ellipsis)
         }
       }
@@ -327,6 +371,7 @@ fun ErrorsScreen() {
       SentryTraced("anr") {
         OutlinedButton(
           onClick = {
+            tagSampleAction("anr")
             Thread {
                 synchronized(mutex) {
                   while (true) {
@@ -341,7 +386,14 @@ fun ErrorsScreen() {
               .start()
 
             Handler(Looper.getMainLooper())
-              .postDelayed({ synchronized(mutex) { throw IllegalStateException() } }, 1000)
+              .postDelayed(
+                {
+                  synchronized(mutex) {
+                    throw IllegalStateException("ANR button: main thread blocked")
+                  }
+                },
+                1000,
+              )
           },
           modifier = Modifier,
         ) {
@@ -353,10 +405,18 @@ fun ErrorsScreen() {
       SentryTraced("native_anr") {
         OutlinedButton(
           onClick = {
+            tagSampleAction("native_anr")
             Thread { NativeSample.freezeMysteriously(mutex) }.start()
 
             Handler(Looper.getMainLooper())
-              .postDelayed({ synchronized(mutex) { throw IllegalStateException() } }, 1000)
+              .postDelayed(
+                {
+                  synchronized(mutex) {
+                    throw IllegalStateException("ANR (native) button: main thread blocked")
+                  }
+                },
+                1000,
+              )
           },
           modifier = Modifier,
         ) {
@@ -368,6 +428,7 @@ fun ErrorsScreen() {
       SentryTraced("out_of_memory") {
         OutlinedButton(
           onClick = {
+            tagSampleAction("out_of_memory")
             val latch = CountDownLatch(1)
             for (i in 0 until 20) {
               Thread {
@@ -393,7 +454,13 @@ fun ErrorsScreen() {
     }
     item {
       SentryTraced("send_message") {
-        OutlinedButton(onClick = { Sentry.captureMessage("Some message.") }, modifier = Modifier) {
+        OutlinedButton(
+          onClick = {
+            tagSampleAction("send_message")
+            Sentry.captureMessage("Send Message button: test message")
+          },
+          modifier = Modifier,
+        ) {
           Text("Send Message", maxLines = 2, overflow = TextOverflow.Ellipsis)
         }
       }
@@ -402,11 +469,12 @@ fun ErrorsScreen() {
       SentryTraced("test_timber") {
         OutlinedButton(
           onClick = {
+            tagSampleAction("test_timber")
             crashCount.intValue++
-            Timber.i("Some info here")
+            Timber.i("Test Timber button: info log")
             Timber.e(
-              RuntimeException("Uncaught Exception from Java."),
-              "Something wrong happened ${crashCount.intValue} times",
+              RuntimeException("Test Timber button: error RuntimeException"),
+              "Test Timber button: error logged ${crashCount.intValue} times",
             )
           },
           modifier = Modifier,
@@ -935,3 +1003,8 @@ fun Context.getActivity(): ComponentActivity {
 fun stackOverflow() {
   stackOverflow()
 }
+
+private fun tagSampleAction(action: String) {
+  // Tag every event with the button that triggered it so it can be filtered in Sentry.
+  Sentry.setTag("sample_action", action)
+}

From dfd01a34424933ea02d092e4c08a9454a874974b Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 6 Jul 2026 14:48:14 +0200
Subject: [PATCH 270/391] refactor(core): Consolidate scope-persistence error
 handling (JAVA-608) (#5692)

Extract the duplicated try/catch in PersistingScopeObserver.serializeToDisk
into a single runSafely helper used by both the on-executor and submit
paths. Pure internal cleanup; error-handling behavior is unchanged.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../sentry/cache/PersistingScopeObserver.java | 25 ++++++++-----------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java b/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
index c9356579c9c..edfcc71b9a6 100644
--- a/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
+++ b/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
@@ -231,30 +231,25 @@ private void serializeToDisk(final @NotNull Runnable task) {
     }
     if (Thread.currentThread().getName().contains("SentryExecutor")) {
       // we're already on the sentry executor thread, so we can just execute it directly
-      try {
-        task.run();
-      } catch (Throwable e) {
-        options.getLogger().log(ERROR, "Serialization task failed", e);
-      }
+      runSafely(task);
       return;
     }
 
     try {
-      options
-          .getExecutorService()
-          .submit(
-              () -> {
-                try {
-                  task.run();
-                } catch (Throwable e) {
-                  options.getLogger().log(ERROR, "Serialization task failed", e);
-                }
-              });
+      options.getExecutorService().submit(() -> runSafely(task));
     } catch (Throwable e) {
       options.getLogger().log(ERROR, "Serialization task could not be scheduled", e);
     }
   }
 
+  private void runSafely(final @NotNull Runnable task) {
+    try {
+      task.run();
+    } catch (Throwable e) {
+      options.getLogger().log(ERROR, "Serialization task failed", e);
+    }
+  }
+
   private <T> void store(final @NotNull T entity, final @NotNull String fileName) {
     store(options, entity, fileName);
   }

From 2d4376bf9b4a6f583b5e47966429477a923a8574 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 6 Jul 2026 15:01:30 +0200
Subject: [PATCH 271/391] perf(core): Skip Hint allocation in addBreadcrumb
 (JAVA-605) (#5689)

Only allocate a Hint when a beforeBreadcrumb callback is set. addBreadcrumb
previously allocated a Hint (HashMap + ArrayList + lock) on every call even
though the Hint is only ever passed to the callback, wasting allocations on
the common no-callback path.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                              | 4 ++++
 sentry/src/main/java/io/sentry/Scope.java | 7 +++----
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e082da5f172..81a7975bfb4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,10 @@
 - Name the device-info caching thread `SentryDeviceInfoCache` so all threads spawned by the SDK are identifiable ([#5684](https://github.com/getsentry/sentry-java/pull/5684))
 - Apply byte-category rate limits to log and trace metric envelope items ([#5716](https://github.com/getsentry/sentry-java/pull/5716))
 
+### Performance
+
+- Skip `Hint` allocation in `Scope.addBreadcrumb` when no `beforeBreadcrumb` callback is set ([#5689](https://github.com/getsentry/sentry-java/pull/5689))
+
 ## 8.47.0
 
 ### Behavioral Changes
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index 282fc4df67f..f5c57f5ac5d 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -493,12 +493,11 @@ public void addBreadcrumb(@NotNull Breadcrumb breadcrumb, @Nullable Hint hint) {
     if (breadcrumb == null || breadcrumbs instanceof DisabledQueue) {
       return;
     }
-    if (hint == null) {
-      hint = new Hint();
-    }
-
     SentryOptions.BeforeBreadcrumbCallback callback = options.getBeforeBreadcrumb();
     if (callback != null) {
+      if (hint == null) {
+        hint = new Hint();
+      }
       breadcrumb = executeBeforeBreadcrumb(callback, breadcrumb, hint);
     }
     if (breadcrumb != null) {

From 90ff16253f8c0847ef95ba4880db1acb600b1b7c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Jul 2026 15:33:17 +0200
Subject: [PATCH 272/391] chore(deps): bump
 reactivecircus/android-emulator-runner (#5719)

Bumps the github-actions group with 1 update: [reactivecircus/android-emulator-runner](https://github.com/reactivecircus/android-emulator-runner).


Updates `reactivecircus/android-emulator-runner` from 2.37.0 to 2.38.0
- [Release notes](https://github.com/reactivecircus/android-emulator-runner/releases)
- [Changelog](https://github.com/ReactiveCircus/android-emulator-runner/blob/main/CHANGELOG.md)
- [Commits](https://github.com/reactivecircus/android-emulator-runner/compare/e89f39f1abbbd05b1113a29cf4db69e7540cae5a...a421e43855164a8197daf9d8d40fe71c6996bb0d)

---
updated-dependencies:
- dependency-name: reactivecircus/android-emulator-runner
  dependency-version: 2.38.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 4 ++--
 .github/workflows/integration-tests-ui-critical.yml | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index e6f2a560d21..13809a303a8 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -60,7 +60,7 @@ jobs:
 
       - name: Create AVD and generate snapshot for caching
         if: steps.avd-cache.outputs.cache-hit != 'true'
-        uses: reactivecircus/android-emulator-runner@e89f39f1abbbd05b1113a29cf4db69e7540cae5a # pin@v2
+        uses: reactivecircus/android-emulator-runner@a421e43855164a8197daf9d8d40fe71c6996bb0d # pin@v2
         with:
           api-level: 30
           target: aosp_atd
@@ -79,7 +79,7 @@ jobs:
 
       # We tried to use the cache action to cache gradle stuff, but it made tests slower and timeout
       - name: Run instrumentation tests
-        uses: reactivecircus/android-emulator-runner@e89f39f1abbbd05b1113a29cf4db69e7540cae5a # pin@v2
+        uses: reactivecircus/android-emulator-runner@a421e43855164a8197daf9d8d40fe71c6996bb0d # pin@v2
         with:
           api-level: 30
           target: aosp_atd
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index e5d4f2c65dd..252e7a5a149 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -96,7 +96,7 @@ jobs:
 
       - name: Create AVD and generate snapshot for caching
         if: steps.avd-cache.outputs.cache-hit != 'true'
-        uses: reactivecircus/android-emulator-runner@e89f39f1abbbd05b1113a29cf4db69e7540cae5a # pin@v2
+        uses: reactivecircus/android-emulator-runner@a421e43855164a8197daf9d8d40fe71c6996bb0d # pin@v2
         with:
           api-level: ${{ matrix.api-level }}
           target: ${{ matrix.target }}
@@ -120,7 +120,7 @@ jobs:
           version: ${{env.MAESTRO_VERSION}}
 
       - name: Run tests
-        uses: reactivecircus/android-emulator-runner@e89f39f1abbbd05b1113a29cf4db69e7540cae5a # pin@v2.37.0
+        uses: reactivecircus/android-emulator-runner@a421e43855164a8197daf9d8d40fe71c6996bb0d # pin@v2.38.0
         with:
           api-level: ${{ matrix.api-level }}
           target: ${{ matrix.target }}

From 87f4f63c06c855d7424ad789e9d9bd6969efef7b Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 6 Jul 2026 15:44:20 +0200
Subject: [PATCH 273/391] perf(core): Detect Sentry executor thread without a
 name scan (#5691)

* perf(core): Detect Sentry executor thread without name scan (JAVA-607)

PersistingScopeObserver.serializeToDisk gated the on-executor fast path by
scanning Thread.currentThread().getName(), which allocates a String and
scans it on every scope mutation (breadcrumb, tag, trace, ...). Tag the
executor threads with a marker Thread subclass and expose an allocation-free
SentryExecutorService.isSentryExecutorThread() check instead.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* Format code

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                   |  1 +
 sentry/api/sentry.api                          |  1 +
 .../java/io/sentry/SentryExecutorService.java  | 18 +++++++++++++++++-
 .../sentry/cache/PersistingScopeObserver.java  |  3 ++-
 4 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 81a7975bfb4..3505a359c36 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,7 @@
 ### Performance
 
 - Skip `Hint` allocation in `Scope.addBreadcrumb` when no `beforeBreadcrumb` callback is set ([#5689](https://github.com/getsentry/sentry-java/pull/5689))
+- Speed up scope persistence by detecting the Sentry executor thread via a marker instead of a `Thread.getName()` name scan on every scope mutation ([#5691](https://github.com/getsentry/sentry-java/pull/5691))
 
 ## 8.47.0
 
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index d62ecf41193..5b37d89e848 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -3182,6 +3182,7 @@ public final class io/sentry/SentryExecutorService : io/sentry/ISentryExecutorSe
 	public fun <init> (Lio/sentry/SentryOptions;)V
 	public fun close (J)V
 	public fun isClosed ()Z
+	public static fun isSentryExecutorThread ()Z
 	public fun prewarm ()V
 	public fun schedule (Ljava/lang/Runnable;J)Ljava/util/concurrent/Future;
 	public fun submit (Ljava/lang/Runnable;)Ljava/util/concurrent/Future;
diff --git a/sentry/src/main/java/io/sentry/SentryExecutorService.java b/sentry/src/main/java/io/sentry/SentryExecutorService.java
index adb50b232e9..3e24a1a5992 100644
--- a/sentry/src/main/java/io/sentry/SentryExecutorService.java
+++ b/sentry/src/main/java/io/sentry/SentryExecutorService.java
@@ -149,17 +149,33 @@ public void prewarm() {
     }
   }
 
+  /**
+   * Whether the calling thread is one of the Sentry executor threads. Cheap replacement for
+   * scanning {@code Thread.currentThread().getName()}, which is on hot paths (e.g. scope
+   * persistence on every scope mutation).
+   */
+  public static boolean isSentryExecutorThread() {
+    return Thread.currentThread() instanceof SentryExecutorServiceThread;
+  }
+
   private static final class SentryExecutorServiceThreadFactory implements ThreadFactory {
     private int cnt;
 
     @Override
     public @NotNull Thread newThread(final @NotNull Runnable r) {
-      final Thread ret = new Thread(r, "SentryExecutorServiceThreadFactory-" + cnt++);
+      final Thread ret =
+          new SentryExecutorServiceThread(r, "SentryExecutorServiceThreadFactory-" + cnt++);
       ret.setDaemon(true);
       return ret;
     }
   }
 
+  private static final class SentryExecutorServiceThread extends Thread {
+    SentryExecutorServiceThread(final @NotNull Runnable r, final @NotNull String name) {
+      super(r, name);
+    }
+  }
+
   private static final class CancelledFuture<T> implements Future<T> {
     @Override
     public boolean cancel(final boolean mayInterruptIfRunning) {
diff --git a/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java b/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
index edfcc71b9a6..420d0d31e22 100644
--- a/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
+++ b/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
@@ -7,6 +7,7 @@
 import io.sentry.Breadcrumb;
 import io.sentry.IScope;
 import io.sentry.ScopeObserverAdapter;
+import io.sentry.SentryExecutorService;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
 import io.sentry.SpanContext;
@@ -229,7 +230,7 @@ private void serializeToDisk(final @NotNull Runnable task) {
     if (!options.isEnableScopePersistence()) {
       return;
     }
-    if (Thread.currentThread().getName().contains("SentryExecutor")) {
+    if (SentryExecutorService.isSentryExecutorThread()) {
       // we're already on the sentry executor thread, so we can just execute it directly
       runSafely(task);
       return;

From 7a19fee20086191757be1dfc629c34c5e2f20bee Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 6 Jul 2026 16:34:06 +0200
Subject: [PATCH 274/391] perf(core): Remove executor prewarm (#5681)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

SentryExecutorService is single-threaded, and prewarm() is submitted ahead
of loadLazyFields() during init, so its 40-task schedule/cancel/purge loop
cannot reduce first-task latency — it can only delay it. The thread creation
and executor class loading it aimed to warm are paid identically by the first
real task (loadLazyFields), which is submitted unconditionally right after,
so prewarm warms nothing that would not already be warmed.

On-device A/B benchmarks on a Galaxy A55 (Android 16) show no measurable
first-useful-task speedup from prewarm and ~20us of extra background-thread
work. Remove prewarm() from ISentryExecutorService and its implementations
and from both init call sites.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  2 +
 .../android/core/AndroidProfilerTest.kt       |  2 -
 .../core/AndroidTransactionProfilerTest.kt    |  2 -
 .../src/main/kotlin/io/sentry/test/Mocks.kt   |  6 ---
 sentry/api/sentry.api                         |  3 --
 .../io/sentry/ISentryExecutorService.java     |  6 ---
 .../io/sentry/NoOpSentryExecutorService.java  |  3 --
 sentry/src/main/java/io/sentry/Sentry.java    |  1 -
 .../java/io/sentry/SentryExecutorService.java | 39 -------------------
 .../main/java/io/sentry/SentryOptions.java    |  1 -
 .../io/sentry/SentryExecutorServiceTest.kt    | 16 --------
 sentry/src/test/java/io/sentry/SentryTest.kt  |  1 -
 12 files changed, 2 insertions(+), 80 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3505a359c36..107b916808a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,8 @@
 
 - Skip `Hint` allocation in `Scope.addBreadcrumb` when no `beforeBreadcrumb` callback is set ([#5689](https://github.com/getsentry/sentry-java/pull/5689))
 - Speed up scope persistence by detecting the Sentry executor thread via a marker instead of a `Thread.getName()` name scan on every scope mutation ([#5691](https://github.com/getsentry/sentry-java/pull/5691))
+- Remove executor prewarm during SDK init ([#5681](https://github.com/getsentry/sentry-java/pull/5681))
+  - The single-threaded `SentryExecutorService` queued the prewarm work ahead of the first useful task, so it could only delay init work, never speed it up; the thread and class loading it warmed are paid identically by the first real task submitted right after.
 
 ## 8.47.0
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidProfilerTest.kt
index 66bda9bce0b..f402af24f80 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidProfilerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidProfilerTest.kt
@@ -81,8 +81,6 @@ class AndroidProfilerTest {
         override fun close(timeoutMillis: Long) {}
 
         override fun isClosed() = false
-
-        override fun prewarm() = Unit
       }
 
     val options =
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidTransactionProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidTransactionProfilerTest.kt
index 0829e4dc796..b37a6bbdee5 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidTransactionProfilerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidTransactionProfilerTest.kt
@@ -89,8 +89,6 @@ class AndroidTransactionProfilerTest {
         override fun close(timeoutMillis: Long) {}
 
         override fun isClosed() = false
-
-        override fun prewarm() = Unit
       }
 
     val options =
diff --git a/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt b/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt
index da69b7cf330..79076e9dc8f 100644
--- a/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt
+++ b/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt
@@ -35,8 +35,6 @@ class ImmediateExecutorService : ISentryExecutorService {
   override fun close(timeoutMillis: Long) {}
 
   override fun isClosed(): Boolean = false
-
-  override fun prewarm() = Unit
 }
 
 class DeferredExecutorService : ISentryExecutorService {
@@ -74,8 +72,6 @@ class DeferredExecutorService : ISentryExecutorService {
 
   override fun isClosed(): Boolean = false
 
-  override fun prewarm() = Unit
-
   fun hasScheduledRunnables(): Boolean = scheduledRunnables.isNotEmpty()
 }
 
@@ -90,8 +86,6 @@ class NonOverridableNoOpSentryExecutorService : ISentryExecutorService {
   override fun close(timeoutMillis: Long) {}
 
   override fun isClosed(): Boolean = false
-
-  override fun prewarm() = Unit
 }
 
 fun createSentryClientMock(enabled: Boolean = true) =
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 5b37d89e848..09ede4804a3 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -1134,7 +1134,6 @@ public abstract interface class io/sentry/ISentryClient {
 public abstract interface class io/sentry/ISentryExecutorService {
 	public abstract fun close (J)V
 	public abstract fun isClosed ()Z
-	public abstract fun prewarm ()V
 	public abstract fun schedule (Ljava/lang/Runnable;J)Ljava/util/concurrent/Future;
 	public abstract fun submit (Ljava/lang/Runnable;)Ljava/util/concurrent/Future;
 	public abstract fun submit (Ljava/util/concurrent/Callable;)Ljava/util/concurrent/Future;
@@ -1880,7 +1879,6 @@ public final class io/sentry/NoOpSentryExecutorService : io/sentry/ISentryExecut
 	public fun close (J)V
 	public static fun getInstance ()Lio/sentry/ISentryExecutorService;
 	public fun isClosed ()Z
-	public fun prewarm ()V
 	public fun schedule (Ljava/lang/Runnable;J)Ljava/util/concurrent/Future;
 	public fun submit (Ljava/lang/Runnable;)Ljava/util/concurrent/Future;
 	public fun submit (Ljava/util/concurrent/Callable;)Ljava/util/concurrent/Future;
@@ -3183,7 +3181,6 @@ public final class io/sentry/SentryExecutorService : io/sentry/ISentryExecutorSe
 	public fun close (J)V
 	public fun isClosed ()Z
 	public static fun isSentryExecutorThread ()Z
-	public fun prewarm ()V
 	public fun schedule (Ljava/lang/Runnable;J)Ljava/util/concurrent/Future;
 	public fun submit (Ljava/lang/Runnable;)Ljava/util/concurrent/Future;
 	public fun submit (Ljava/util/concurrent/Callable;)Ljava/util/concurrent/Future;
diff --git a/sentry/src/main/java/io/sentry/ISentryExecutorService.java b/sentry/src/main/java/io/sentry/ISentryExecutorService.java
index ffad05361f6..9bdef8db2b7 100644
--- a/sentry/src/main/java/io/sentry/ISentryExecutorService.java
+++ b/sentry/src/main/java/io/sentry/ISentryExecutorService.java
@@ -45,10 +45,4 @@ Future<?> schedule(final @NotNull Runnable runnable, final long delayMillis)
    * @return If the executorService was previously closed
    */
   boolean isClosed();
-
-  /**
-   * Pre-warms the executor service by increasing the initial queue capacity. SHOULD be called
-   * directly after instantiating this executor service.
-   */
-  void prewarm();
 }
diff --git a/sentry/src/main/java/io/sentry/NoOpSentryExecutorService.java b/sentry/src/main/java/io/sentry/NoOpSentryExecutorService.java
index c2ce81f6577..37778c3cc09 100644
--- a/sentry/src/main/java/io/sentry/NoOpSentryExecutorService.java
+++ b/sentry/src/main/java/io/sentry/NoOpSentryExecutorService.java
@@ -38,7 +38,4 @@ public void close(long timeoutMillis) {}
   public boolean isClosed() {
     return false;
   }
-
-  @Override
-  public void prewarm() {}
 }
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index 919607e5879..f5397f191ad 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -351,7 +351,6 @@ private static void init(final @NotNull SentryOptions options, final boolean glo
         // to set a new one
         if (options.getExecutorService().isClosed()) {
           options.setExecutorService(new SentryExecutorService(options));
-          options.getExecutorService().prewarm();
         }
 
         // load lazy fields of the options in a separate thread
diff --git a/sentry/src/main/java/io/sentry/SentryExecutorService.java b/sentry/src/main/java/io/sentry/SentryExecutorService.java
index 3e24a1a5992..1936bb9c360 100644
--- a/sentry/src/main/java/io/sentry/SentryExecutorService.java
+++ b/sentry/src/main/java/io/sentry/SentryExecutorService.java
@@ -16,13 +16,6 @@
 @ApiStatus.Internal
 public final class SentryExecutorService implements ISentryExecutorService {
 
-  /**
-   * ScheduledThreadPoolExecutor grows work queue by 50% each time. With the initial capacity of 16
-   * it will have to resize 4 times to reach 40, which is a decent middle-ground for prewarming.
-   * This will prevent from growing in unexpected areas of the SDK.
-   */
-  private static final int INITIAL_QUEUE_SIZE = 40;
-
   /**
    * By default, the work queue is unbounded so it can grow as much as the memory allows. We want to
    * limit it by 271 which would be x8 times growth from the default initial capacity.
@@ -32,9 +25,6 @@ public final class SentryExecutorService implements ISentryExecutorService {
   private final @NotNull ScheduledThreadPoolExecutor executorService;
   private final @NotNull AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
 
-  @SuppressWarnings("UnnecessaryLambda")
-  private final @NotNull Runnable dummyRunnable = () -> {};
-
   private final @Nullable SentryOptions options;
 
   @TestOnly
@@ -120,35 +110,6 @@ public boolean isClosed() {
     }
   }
 
-  @SuppressWarnings({"FutureReturnValueIgnored"})
-  @Override
-  public void prewarm() {
-    try {
-      executorService.submit(
-          () -> {
-            try {
-              // schedule a bunch of dummy runnables in the future that will never execute to
-              // trigger
-              // queue growth and then purge the queue
-              for (int i = 0; i < INITIAL_QUEUE_SIZE; i++) {
-                final Future<?> future =
-                    executorService.schedule(dummyRunnable, 365L, TimeUnit.DAYS);
-                future.cancel(true);
-              }
-              executorService.purge();
-            } catch (RejectedExecutionException ignored) {
-              // ignore
-            }
-          });
-    } catch (RejectedExecutionException e) {
-      if (options != null) {
-        options
-            .getLogger()
-            .log(SentryLevel.WARNING, "Prewarm task rejected from " + executorService, e);
-      }
-    }
-  }
-
   /**
    * Whether the calling thread is one of the Sentry executor threads. Cheap replacement for
    * scanning {@code Thread.currentThread().getName()}, which is on hot paths (e.g. scope
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 0d038482d07..8c995001016 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -678,7 +678,6 @@ public void activate() {
       // SentryExecutorService should be initialized before any
       // SendCachedEventFireAndForgetIntegration
       executorService = new SentryExecutorService(this);
-      executorService.prewarm();
     }
 
     // SpotlightIntegration is loaded via reflection to allow the sentry-spotlight module
diff --git a/sentry/src/test/java/io/sentry/SentryExecutorServiceTest.kt b/sentry/src/test/java/io/sentry/SentryExecutorServiceTest.kt
index 2ccba650ad9..57dfb578ee9 100644
--- a/sentry/src/test/java/io/sentry/SentryExecutorServiceTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryExecutorServiceTest.kt
@@ -1,6 +1,5 @@
 package io.sentry
 
-import io.sentry.test.getProperty
 import java.util.concurrent.BlockingQueue
 import java.util.concurrent.Callable
 import java.util.concurrent.CancellationException
@@ -191,21 +190,6 @@ class SentryExecutorServiceTest {
     verify(executor).schedule(any<Runnable>(), any(), any())
   }
 
-  @Test
-  fun `SentryExecutorService prewarm schedules dummy tasks and clears queue`() {
-    val executor = ScheduledThreadPoolExecutor(1)
-
-    val sentryExecutor = SentryExecutorService(executor, null)
-    sentryExecutor.prewarm()
-
-    Thread.sleep(1000)
-
-    // the internal queue/array should be resized 4 times to 54
-    assertEquals(54, (executor.queue.getProperty("queue") as Array<*>).size)
-    // the queue should be empty
-    assertEquals(0, executor.queue.size)
-  }
-
   @Test
   fun `SentryExecutorService schedules any number of job`() {
     val executor = ScheduledThreadPoolExecutor(1)
diff --git a/sentry/src/test/java/io/sentry/SentryTest.kt b/sentry/src/test/java/io/sentry/SentryTest.kt
index 3712b083de7..4a122f11422 100644
--- a/sentry/src/test/java/io/sentry/SentryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTest.kt
@@ -778,7 +778,6 @@ class SentryTest {
       it.cacheDirPath = getTempPath()
       it.setLogger(logger)
       it.executorService = SentryExecutorService()
-      it.executorService.prewarm()
       it.executorService.close(0)
       it.isDebug = true
     }

From 803fad4d09f2632021bfb77c98c0813256e0739e Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 7 Jul 2026 11:05:51 +0200
Subject: [PATCH 275/391] feat(samples): Distinguish debug and release builds
 of the Android sample (#5724)

Give the Android sample a `.debug` application id suffix and a
"Sentry Sample Debug" launcher label so debug and release builds can be
installed side by side and told apart on the home screen. Add a build
type badge (DEBUG/RELEASE) under the Sentry logo in the navigation rail
so the running build is visible inside the app too.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 sentry-samples/sentry-samples-android/build.gradle.kts |  2 ++
 .../src/debug/res/values/strings.xml                   |  4 ++++
 .../java/io/sentry/samples/android/MainActivity.kt     | 10 ++++++++++
 .../src/main/res/values/strings.xml                    |  1 -
 .../src/release/res/values/strings.xml                 |  4 ++++
 5 files changed, 20 insertions(+), 1 deletion(-)
 create mode 100644 sentry-samples/sentry-samples-android/src/debug/res/values/strings.xml
 create mode 100644 sentry-samples/sentry-samples-android/src/release/res/values/strings.xml

diff --git a/sentry-samples/sentry-samples-android/build.gradle.kts b/sentry-samples/sentry-samples-android/build.gradle.kts
index 96ded862f95..f994081450d 100644
--- a/sentry-samples/sentry-samples-android/build.gradle.kts
+++ b/sentry-samples/sentry-samples-android/build.gradle.kts
@@ -111,6 +111,8 @@ android {
 
   buildTypes {
     getByName("debug") {
+      // Suffix the id so debug and release builds can be installed side by side.
+      applicationIdSuffix = ".debug"
       addManifestPlaceholders(mapOf("sentryDebug" to true, "sentryEnvironment" to "debug"))
     }
     getByName("release") {
diff --git a/sentry-samples/sentry-samples-android/src/debug/res/values/strings.xml b/sentry-samples/sentry-samples-android/src/debug/res/values/strings.xml
new file mode 100644
index 00000000000..ef5dee529b6
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/debug/res/values/strings.xml
@@ -0,0 +1,4 @@
+<resources>
+  <string name="app_name">Sentry Sample Debug</string>
+  <string name="build_type">DEBUG</string>
+</resources>
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
index 9fdcaafb008..90e75feee71 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
@@ -77,6 +77,7 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.font.FontWeight
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
@@ -246,6 +247,15 @@ fun CategoryNavigationRail(
           .padding(12.dp)
           .rotate(rotation.value),
     )
+    Spacer(Modifier.height(8.dp))
+    Text(
+      text = stringResource(R.string.build_type),
+      style = MaterialTheme.typography.labelSmall,
+      fontWeight = FontWeight.Bold,
+      color =
+        if (BuildConfig.DEBUG) MaterialTheme.colorScheme.error
+        else MaterialTheme.colorScheme.primary,
+    )
     Spacer(Modifier.height(16.dp))
     Category.entries.forEach { category ->
       NavigationRailItem(
diff --git a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
index 690e6ea7256..2f42a4bff1d 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
@@ -1,5 +1,4 @@
 <resources>
-  <string name="app_name">Sentry sample</string>
   <string name="crash_from_java">Crash from Java (UncaughtException)</string>
   <string name="out_of_memory">Out of Memory (Mulithreaded)</string>
   <string name="stack_overflow">Stack Overflow</string>
diff --git a/sentry-samples/sentry-samples-android/src/release/res/values/strings.xml b/sentry-samples/sentry-samples-android/src/release/res/values/strings.xml
new file mode 100644
index 00000000000..f227a4c9298
--- /dev/null
+++ b/sentry-samples/sentry-samples-android/src/release/res/values/strings.xml
@@ -0,0 +1,4 @@
+<resources>
+  <string name="app_name">Sentry Sample</string>
+  <string name="build_type">RELEASE</string>
+</resources>

From 61ba1d557461f830dfe2e117465190144ae487c1 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 7 Jul 2026 11:06:21 +0200
Subject: [PATCH 276/391] fix(samples): Add Retrofit R8 full-mode keep rules to
 Android sample (#5727)

The Android sample's release build uses R8 full mode, which strips generic signatures from classes that aren't kept. This broke Retrofit call-adapter creation for GithubAPI, crashing SecondActivity in onResume with 'Unable to create call adapter for interface retrofit2.Call'.

Add the standard Retrofit R8 keep rules (Signature attributes, retrofit2.Call/Response, service interfaces) and keep the Repo response model for Gson.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../sentry-samples-android/proguard-rules.pro        | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/sentry-samples/sentry-samples-android/proguard-rules.pro b/sentry-samples/sentry-samples-android/proguard-rules.pro
index 1165340c893..5f4016f8f72 100644
--- a/sentry-samples/sentry-samples-android/proguard-rules.pro
+++ b/sentry-samples/sentry-samples-android/proguard-rules.pro
@@ -32,3 +32,15 @@
 -dontwarn org.openjsse.javax.net.ssl.SSLParameters
 -dontwarn org.openjsse.javax.net.ssl.SSLSocket
 -dontwarn org.openjsse.net.ssl.OpenJSSE
+
+# Retrofit relies on generic signatures for its service methods. Under R8 full mode these are
+# stripped for classes that aren't kept, which breaks call-adapter creation (SecondActivity's
+# GithubAPI request). Keep the signature attributes and Retrofit's generic types.
+-keepattributes Signature, InnerClasses, EnclosingMethod
+-keep,allowobfuscation,allowshrinking interface retrofit2.Call
+-keep,allowobfuscation,allowshrinking class retrofit2.Response
+-keep,allowobfuscation,allowshrinking class kotlin.coroutines.Continuation
+-if interface * { @retrofit2.http.* <methods>; }
+-keep,allowobfuscation interface <1>
+# Keep the response model so Gson can deserialize it.
+-keep class io.sentry.samples.android.Repo { *; }

From 5f1bb668dd3c837e7c9de9b5dca63c9b5a20bfd7 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 7 Jul 2026 17:46:51 +0200
Subject: [PATCH 277/391] docs(agents): Prefer Google Truth for new unit test
 assertions (#5735)

Steer AI coding agents toward Google Truth's fluent assertThat API for
assertions in new unit tests, while keeping kotlin.test for test
structure. Truth is already a dependency in the sentry module; note that
other modules need testImplementation(libs.google.truth) added before
use.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .cursor/rules/coding.mdc | 2 +-
 AGENTS.md                | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/.cursor/rules/coding.mdc b/.cursor/rules/coding.mdc
index 4e6fd2538a3..fbcda27b120 100644
--- a/.cursor/rules/coding.mdc
+++ b/.cursor/rules/coding.mdc
@@ -31,7 +31,7 @@ sentry-java is the Java and Android SDK for Sentry. This repository contains the
 
 1. Follow existing code style and language
 2. Do not modify the API files (e.g. sentry.api) manually, instead run `./gradlew apiDump` to regenerate them
-3. Write comprehensive tests
+3. Write comprehensive tests. For assertions in new unit tests, prefer Google Truth (`com.google.common.truth.Truth.assertThat`) over `kotlin.test`/JUnit assertions; keep `kotlin.test` for test structure like `@Test` and `assertFailsWith`. Add `testImplementation(libs.google.truth)` to a module's `build.gradle.kts` if it isn't already present.
 4. New features should always be opt-in by default, extend `SentryOptions` or similar Option classes with getters and setters to enable/disable a new feature
 5. Consider backwards compatibility
 
diff --git a/AGENTS.md b/AGENTS.md
index a05d9386607..ec2ef62974c 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -146,6 +146,8 @@ The repository is organized into multiple modules:
 - Write comprehensive unit tests for new features
 - Android modules require both unit tests and instrumented tests where applicable
 - System tests validate end-to-end functionality with sample applications
+- **Assertions**: For new unit tests, prefer [Google Truth](https://truth.dev/) (`com.google.common.truth.Truth.assertThat`) over `kotlin.test`/JUnit assertions for its readable, fluent API. Keep using `kotlin.test` for test structure (`@Test`, `assertFailsWith`). See `sentry/src/test/java/io/sentry/DsnTest.kt` for the style. Don't rewrite existing `kotlin.test` assertions solely to switch libraries.
+- Truth is wired into the `sentry` module. When adding Truth-based tests to another module, add `testImplementation(libs.google.truth)` to that module's `build.gradle.kts`.
 
 ### Contributing Guidelines
 1. Follow existing code style and language

From cc59f486da8416c271765df11627faefcb1ec080 Mon Sep 17 00:00:00 2001
From: Giancarlo Buenaflor <giancarlo_buenaflor@yahoo.com>
Date: Tue, 7 Jul 2026 22:32:45 +0200
Subject: [PATCH 278/391] feat(extend-app-start): App start extension API
 (#5604)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* collection: extend app start

* changelog

* feat(extend-app-start): [1/4] Add IAppStartExtender bridge (#5605)

* feat(extend-app-start): Add IAppStartExtender bridge and SentryOptions wiring

Introduces the @ApiStatus.Internal IAppStartExtender contract (extendAppStart /
finishAppStart / getExtendedAppStartSpan) and a NoOp default, wired into
SentryOptions. This is the naming-stable core bridge for the app start
extension API; it is inert (returns NoOpSpan / no-ops) until the Android
implementation and public Sentry facade land later in the stack.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Annotate NoOpAppStartExtender internal and fix test name typo

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename finishAppStart to finishExtendedAppStart

Mirrors sentry-cocoa's finishExtendedAppLaunch() and makes the API name explicit
about finishing the *extended* app start. Renames IAppStartExtender.finishAppStart()
and the NoOpAppStartExtender implementation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Return null from getExtendedAppStartSpan when inactive

Mirrors Sentry.getSpan(): the extender reports null when there is no active extended span instead of a NoOpSpan, so callers can tell there is no span running.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Remove NoOpAppStartExtenderTest per PR review

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(extend-app-start): Guard setAppStartExtender against null

Match the NoOp-fallback convention used by other SentryOptions setters:
accept a @Nullable argument and coalesce to NoOpAppStartExtender so the
@NotNull field and getter can never be nulled out.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Use setter method for appStartExtender

The @Nullable setter and @NotNull getter no longer form a Kotlin
mutable property, so use setAppStartExtender(...) instead of the
property-assignment syntax (matches setTransportFactory/setReplayController).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* feat(extend-app-start): [2/4] Extract AppStartExtension component (#5606)

* feat(extend-app-start): Add IAppStartExtender bridge and SentryOptions wiring

Introduces the @ApiStatus.Internal IAppStartExtender contract (extendAppStart /
finishAppStart / getExtendedAppStartSpan) and a NoOp default, wired into
SentryOptions. This is the naming-stable core bridge for the app start
extension API; it is inert (returns NoOpSpan / no-ops) until the Android
implementation and public Sentry facade land later in the stack.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Annotate NoOpAppStartExtender internal and fix test name typo

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename finishAppStart to finishExtendedAppStart

Mirrors sentry-cocoa's finishExtendedAppLaunch() and makes the API name explicit
about finishing the *extended* app start. Renames IAppStartExtender.finishAppStart()
and the NoOpAppStartExtender implementation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Extract AppStartExtension component for the Android extender

Replaces the AppStartMetrics IAppStartExtender implementation and the deferred
ExtendedAppStartSpan with a focused, lock-guarded AppStartExtension that owns the
eager App Start transaction and extended span. AppStartMetrics now only holds the
component and exposes isAppStartWindowOpen(). Inert until 3/4 registers the listener.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Inject logger into AppStartExtension instead of static scope lookup

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Return ExtendedAppStart from the listener instead of a callback

The listener now returns the created transaction+span (or null to decline)
rather than calling back into onExtended() while extendAppStart() holds the
lock. This removes the re-entrant lock acquisition and the A->B->A round trip,
collapsing two public methods into one linear flow.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Remove redundant comments and rename reset to clear

Drop comments that restate code or annotate omissions (region markers, getter
javadoc, the reset call-site comment, the ExtendedAppStart/isActive docs). Rename
AppStartExtension.reset() to clear() to match its owner AppStartMetrics.clear().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Inline the logger lookup instead of injecting it

The extension logs only two warnings, both on rare guard paths in extendAppStart().
Inline Sentry.getCurrentScopes().getOptions().getLogger() at those sites instead of
holding a logger field set at init, dropping the field, setLogger(), and the
AndroidOptionsInitializer wiring. extendAppStart() runs post-init, so the lookup
always yields the configured logger.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Drop the class and listener javadocs on AppStartExtension

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Trim finishTransaction/getExtendedEndTime comments

Drop finishTransaction's javadoc (trivial body; it described caller context and
waitForChildren behavior configured elsewhere) and reduce getExtendedEndTime's
javadoc to a single inline note on the only non-obvious branch (deadline suppression).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename AppStartExtension.finishAppStart to finishExtendedAppStart

Implements the renamed IAppStartExtender.finishExtendedAppStart().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Drop the redundant foreground-check comment on extendAppStart

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop the no-value getAppStartExtension test and trim comments

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop the no-op finishExtendedAppStart test

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Read the extended span finish date, not its finished flag

getExtendedEndTime() gated on span.isFinished(), but finishing the extended
span completes the waitForChildren transaction and runs the event processor
re-entrantly within finishExtendedAppStart(), before the span's finished flag
is set. The processor then saw an unfinished span and dropped the app start
measurement whenever the extension finished after the first frame. Read
getFinishDate() (set before the finish callback) instead, which also keeps the
extended end controllable in tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): End the extended transaction at the extended span end

When the extended span finished after the timestamp passed to
finishTransaction() but before that call ran (e.g. a synchronous extension in a
headless start, where finishTransaction runs later at main-thread idle),
waitForChildren had nothing left to wait for and the transaction kept the
earlier passed timestamp. The extended span then ended after the transaction,
and the app start vital exceeded the transaction duration. Finish at
max(endTimestamp, extended span finish date) so the span is contained and the
duration matches the vital.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Guard extendAppStartListener with the lock

The setter wrote the field without synchronization while extendAppStart()
reads it under the lock, leaving no happens-before edge. Acquire the same
lock in the setter, consistent with the rest of the class's mutable state.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim verbose finishTransaction comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Read finish date in getExtendedAppStartSpan

Finishing the extended span runs the event processor re-entrantly (via
the waitForChildren transaction) before the span's isFinished() flag is
set, while the finish timestamp is already in place. Reading isFinished()
could therefore hand out a span that is already finishing. Switch to
getFinishDate() == null, matching getExtendedEndTime().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim duplicated reentrancy comment in getExtendedAppStartSpan

Replace the repeated reentrancy explanation with a cross-reference to
getExtendedEndTime(), which holds the canonical version.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Keep trimmed reentrancy comment within line length

Single-line form fits the 100-char limit so spotless leaves it unwrapped.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Reword getExtendedAppStartSpan reentrancy comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename isAppStartWindowOpen to canExtendAppStart

The predicate has a single consumer — the extend gate in
AppStartExtension — so name it for that intent. Also drop the
self-evident max-end comment in finishTransaction. Regenerated apiDump.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop redundant getExtendedAppStartSpan finished test

After getExtendedAppStartSpan switched to getFinishDate(), the
"after the span finished" case exercises the same branch as the
reentrancy test (finishDate set -> NoOp); the isFinished stub was inert.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Add setData and isExtended to AppStartExtension

Move these component accessors into the component-extraction PR (they were
introduced later in the wiring PR). Keeps the full AppStartExtension surface
and its unit tests together here; the wiring PR only consumes them. Inert on
its own. Regenerated apiDump.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Make shouldSendStartMeasurements volatile

It is written without a lock in onAppStartSpansSent() and read across threads in canExtendAppStart() (via extendAppStart()), with no happens-before edge. volatile guarantees visibility, matching the AtomicInteger/AtomicBoolean siblings in the same check.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(extend-app-start): Explain why AppStartExtension holds span and transaction

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Return null from getExtendedAppStartSpan when inactive

Mirrors Sentry.getSpan(): the extender reports null when there is no active extended span instead of a NoOpSpan, so callers can tell there is no span running.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Return null from AppStartExtension.getExtendedAppStartSpan when inactive

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Use setter method for appStartExtender

The @Nullable setter and @NotNull getter no longer form a Kotlin
mutable property, so use setAppStartExtender(...) instead of the
property-assignment syntax (matches setTransportFactory/setReplayController).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): [3/4] Eagerly create the extended app start transaction (#5608)

* feat(extend-app-start): Add IAppStartExtender bridge and SentryOptions wiring

Introduces the @ApiStatus.Internal IAppStartExtender contract (extendAppStart /
finishAppStart / getExtendedAppStartSpan) and a NoOp default, wired into
SentryOptions. This is the naming-stable core bridge for the app start
extension API; it is inert (returns NoOpSpan / no-ops) until the Android
implementation and public Sentry facade land later in the stack.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Annotate NoOpAppStartExtender internal and fix test name typo

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename finishAppStart to finishExtendedAppStart

Mirrors sentry-cocoa's finishExtendedAppLaunch() and makes the API name explicit
about finishing the *extended* app start. Renames IAppStartExtender.finishAppStart()
and the NoOpAppStartExtender implementation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Extract AppStartExtension component for the Android extender

Replaces the AppStartMetrics IAppStartExtender implementation and the deferred
ExtendedAppStartSpan with a focused, lock-guarded AppStartExtension that owns the
eager App Start transaction and extended span. AppStartMetrics now only holds the
component and exposes isAppStartWindowOpen(). Inert until 3/4 registers the listener.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Inject logger into AppStartExtension instead of static scope lookup

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Return ExtendedAppStart from the listener instead of a callback

The listener now returns the created transaction+span (or null to decline)
rather than calling back into onExtended() while extendAppStart() holds the
lock. This removes the re-entrant lock acquisition and the A->B->A round trip,
collapsing two public methods into one linear flow.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Remove redundant comments and rename reset to clear

Drop comments that restate code or annotate omissions (region markers, getter
javadoc, the reset call-site comment, the ExtendedAppStart/isActive docs). Rename
AppStartExtension.reset() to clear() to match its owner AppStartMetrics.clear().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Inline the logger lookup instead of injecting it

The extension logs only two warnings, both on rare guard paths in extendAppStart().
Inline Sentry.getCurrentScopes().getOptions().getLogger() at those sites instead of
holding a logger field set at init, dropping the field, setLogger(), and the
AndroidOptionsInitializer wiring. extendAppStart() runs post-init, so the lookup
always yields the configured logger.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Drop the class and listener javadocs on AppStartExtension

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Trim finishTransaction/getExtendedEndTime comments

Drop finishTransaction's javadoc (trivial body; it described caller context and
waitForChildren behavior configured elsewhere) and reduce getExtendedEndTime's
javadoc to a single inline note on the only non-obvious branch (deadline suppression).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename AppStartExtension.finishAppStart to finishExtendedAppStart

Implements the renamed IAppStartExtender.finishExtendedAppStart().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Eagerly create the extended App Start transaction (standalone-only)

Registers an extend-listener on AppStartExtension that eagerly creates the
standalone app.start transaction + extended child span in Application.onCreate,
held open via waitForChildren until Sentry.finishAppStart() or the deadline. The
first activity continues the eager trace into ui.load (attaching the screen so it
stays a foreground app.start) instead of creating a second app.start; headless
finishes the eager txn. The app start vital is max(natural, extended) so an early
finish never shortens it, and is suppressed on deadline. Standalone-only.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Drop the redundant foreground-check comment on extendAppStart

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Replace the no-op finish test with isExtended coverage

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop the no-value getAppStartExtension test and trim comments

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Drop the redundant foreground-check comment on extendAppStart

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop the no-value getAppStartExtension test and trim comments

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop the no-op finishExtendedAppStart test

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Trim and de-duplicate comments in the eager app start path

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Clarify the extensionActive comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Read the extended span finish date, not its finished flag

getExtendedEndTime() gated on span.isFinished(), but finishing the extended
span completes the waitForChildren transaction and runs the event processor
re-entrantly within finishExtendedAppStart(), before the span's finished flag
is set. The processor then saw an unfinished span and dropped the app start
measurement whenever the extension finished after the first frame. Read
getFinishDate() (set before the finish callback) instead, which also keeps the
extended end controllable in tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): End the extended transaction at the extended span end

When the extended span finished after the timestamp passed to
finishTransaction() but before that call ran (e.g. a synchronous extension in a
headless start, where finishTransaction runs later at main-thread idle),
waitForChildren had nothing left to wait for and the transaction kept the
earlier passed timestamp. The extended span then ended after the transaction,
and the app start vital exceeded the transaction duration. Finish at
max(endTimestamp, extended span finish date) so the span is contained and the
duration matches the vital.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* ref(extend-app-start): Rename extended app start span op to app.start.extended

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Guard extendAppStartListener with the lock

The setter wrote the field without synchronization while extendAppStart()
reads it under the lock, leaving no happens-before edge. Acquire the same
lock in the setter, consistent with the rest of the class's mutable state.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Fix headless app start end time and duplicate txn

Two issues in onHeadlessAppStart for extended starts:
- The extended branch finished the eager transaction but never persisted
  appStartEndTime, leaving the continuation window unbounded so a later
  activity would wrongly continue the stale trace. Persist it on all paths.
- The branch only checked isActive(), so if the extension already finished
  (finishExtendedAppStart or the deadline) before the headless idle ran, a
  second, empty standalone app.start was created. Guard on
  shouldSendStartMeasurements to avoid the duplicate.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim low-value comments in the headless fix

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Drop redundant extend-listener comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim redundant comments in onActivityCreated

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Remove explanatory comments in app start paths

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Consume stored app start trace on the extension path

The first activity continuing an extended app.start did not clear the stored
trace headers (only the headless-follow path did), so a later activity saw
them and wrongly reused the finished app start trace. Clear them on the
extension path too.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Only the launch activity attaches the app start screen

While the extension was open, every activity's onActivityCreated re-attached
app.vitals.start.screen to the eager app.start, so a second activity opened
before finishExtendedAppStart() overwrote the launch screen. Gate the attach
on isAppStart so only the launch activity sets it.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Format code

* style(extend-app-start): Trim verbose finishTransaction comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim verbose comments in app start paths

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Read finish date in getExtendedAppStartSpan

Finishing the extended span runs the event processor re-entrantly (via
the waitForChildren transaction) before the span's isFinished() flag is
set, while the finish timestamp is already in place. Reading isFinished()
could therefore hand out a span that is already finishing. Switch to
getFinishDate() == null, matching getExtendedEndTime().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim duplicated reentrancy comment in getExtendedAppStartSpan

Replace the repeated reentrancy explanation with a cross-reference to
getExtendedEndTime(), which holds the canonical version.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Keep trimmed reentrancy comment within line length

Single-line form fits the 100-char limit so spotless leaves it unwrapped.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Drop two line-narrating test comments

Remove comments that restated the adjacent test code (the eager
extendAppStart call and the second-activity open).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Reword getExtendedAppStartSpan reentrancy comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename isAppStartWindowOpen to canExtendAppStart

The predicate has a single consumer — the extend gate in
AppStartExtension — so name it for that intent. Also drop the
self-evident max-end comment in finishTransaction. Regenerated apiDump.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop redundant getExtendedAppStartSpan finished test

After getExtendedAppStartSpan switched to getFinishDate(), the
"after the span finished" case exercises the same branch as the
reentrancy test (finishDate set -> NoOp); the isFinished stub was inert.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop narrating comments from app start tests

The test names describe the scenarios; the inline comments restated them.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Add setData and isExtended to AppStartExtension

Move these component accessors into the component-extraction PR (they were
introduced later in the wiring PR). Keeps the full AppStartExtension surface
and its unit tests together here; the wiring PR only consumes them. Inert on
its own. Regenerated apiDump.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Name app start branching booleans by intent

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Make shouldSendStartMeasurements volatile

It is written without a lock in onAppStartSpansSent() and read across threads in canExtendAppStart() (via extendAppStart()), with no happens-before edge. volatile guarantees visibility, matching the AtomicInteger/AtomicBoolean siblings in the same check.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(extend-app-start): Explain why AppStartExtension holds span and transaction

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Return null from getExtendedAppStartSpan when inactive

Mirrors Sentry.getSpan(): the extender reports null when there is no active extended span instead of a NoOpSpan, so callers can tell there is no span running.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Return null from AppStartExtension.getExtendedAppStartSpan when inactive

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Assert null extended span now that getExtendedAppStartSpan is nullable

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(extend-app-start): Explain single-use app start sampling decision

The get-then-clear of the app start sampling decision in
onExtendAppStartRequested looks redundant without context. Document
that the decision is pre-rolled on the previous run, forces the eager
app.start transaction's sampling and profiler binding, and must be
cleared so the first ui.load can't also claim it.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(extend-app-start): Bound the trace continuation window after an eager extension finishes

The eager extendAppStart path persists trace headers so a later
ui.load can continue the app.start trace, but never recorded the app
start end time - that was only set on the headless path. If the
extended transaction finished (user finish or deadline) before any
activity, the first ui.load treated the continuation window as
unbounded and joined the completed app-start trace no matter how much
later it started.

Persist the transaction's finish date via the transaction finished
callback, which covers every finish path (finishExtendedAppStart,
first frame, deadline), so the existing continuation window check
bounds the extend path the same way it bounds the headless one.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(extend-app-start): Skip warm-start reclassification while the extension is active

A first activity arriving more than a minute after launch resets the
app start span to the activity create time and flips the type to warm.
While an app start extension is active this corrupts the extended
vital: the eager app.start transaction stays anchored at process start
while the measurement subtracts the reset span start, and a cold
launch gets reported under the warm key.

An active extension is the user explicitly saying the launch is still
in progress, so let it pin the launch: skip the reclassification while
the extension is active and apply the heuristic as before once it has
finished.

Co-Authored-By: Claude <noreply@anthropic.com>

* test(extend-app-start): Remove NoOpAppStartExtenderTest per PR review

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>

* feat(extend-app-start): [4/4] Add public Sentry app start extension API and update example app (#5628)

* feat(extend-app-start): Add IAppStartExtender bridge and SentryOptions wiring

Introduces the @ApiStatus.Internal IAppStartExtender contract (extendAppStart /
finishAppStart / getExtendedAppStartSpan) and a NoOp default, wired into
SentryOptions. This is the naming-stable core bridge for the app start
extension API; it is inert (returns NoOpSpan / no-ops) until the Android
implementation and public Sentry facade land later in the stack.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Annotate NoOpAppStartExtender internal and fix test name typo

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename finishAppStart to finishExtendedAppStart

Mirrors sentry-cocoa's finishExtendedAppLaunch() and makes the API name explicit
about finishing the *extended* app start. Renames IAppStartExtender.finishAppStart()
and the NoOpAppStartExtender implementation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Extract AppStartExtension component for the Android extender

Replaces the AppStartMetrics IAppStartExtender implementation and the deferred
ExtendedAppStartSpan with a focused, lock-guarded AppStartExtension that owns the
eager App Start transaction and extended span. AppStartMetrics now only holds the
component and exposes isAppStartWindowOpen(). Inert until 3/4 registers the listener.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Inject logger into AppStartExtension instead of static scope lookup

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Return ExtendedAppStart from the listener instead of a callback

The listener now returns the created transaction+span (or null to decline)
rather than calling back into onExtended() while extendAppStart() holds the
lock. This removes the re-entrant lock acquisition and the A->B->A round trip,
collapsing two public methods into one linear flow.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Remove redundant comments and rename reset to clear

Drop comments that restate code or annotate omissions (region markers, getter
javadoc, the reset call-site comment, the ExtendedAppStart/isActive docs). Rename
AppStartExtension.reset() to clear() to match its owner AppStartMetrics.clear().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Inline the logger lookup instead of injecting it

The extension logs only two warnings, both on rare guard paths in extendAppStart().
Inline Sentry.getCurrentScopes().getOptions().getLogger() at those sites instead of
holding a logger field set at init, dropping the field, setLogger(), and the
AndroidOptionsInitializer wiring. extendAppStart() runs post-init, so the lookup
always yields the configured logger.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Drop the class and listener javadocs on AppStartExtension

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Trim finishTransaction/getExtendedEndTime comments

Drop finishTransaction's javadoc (trivial body; it described caller context and
waitForChildren behavior configured elsewhere) and reduce getExtendedEndTime's
javadoc to a single inline note on the only non-obvious branch (deadline suppression).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename AppStartExtension.finishAppStart to finishExtendedAppStart

Implements the renamed IAppStartExtender.finishExtendedAppStart().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Eagerly create the extended App Start transaction (standalone-only)

Registers an extend-listener on AppStartExtension that eagerly creates the
standalone app.start transaction + extended child span in Application.onCreate,
held open via waitForChildren until Sentry.finishAppStart() or the deadline. The
first activity continues the eager trace into ui.load (attaching the screen so it
stays a foreground app.start) instead of creating a second app.start; headless
finishes the eager txn. The app start vital is max(natural, extended) so an early
finish never shortens it, and is suppressed on deadline. Standalone-only.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Add public Sentry app start extension API

Static bridge delegating to options.getAppStartExtender(): extendAppStart(),
finishAppStart(), getExtendedAppStartSpan(). No-op when the SDK is disabled or the
platform provides no app start extender. Completes the extend app start feature (4/4).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Drop the redundant foreground-check comment on extendAppStart

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Replace the no-op finish test with isExtended coverage

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop the no-value getAppStartExtension test and trim comments

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Drop the redundant foreground-check comment on extendAppStart

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop the no-value getAppStartExtension test and trim comments

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop the no-op finishExtendedAppStart test

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Trim and de-duplicate comments in the eager app start path

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore(extend-app-start): Clarify the extensionActive comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Show extending the app start in the Android sample

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Read the extended span finish date, not its finished flag

getExtendedEndTime() gated on span.isFinished(), but finishing the extended
span completes the waitForChildren transaction and runs the event processor
re-entrantly within finishExtendedAppStart(), before the span's finished flag
is set. The processor then saw an unfinished span and dropped the app start
measurement whenever the extension finished after the first frame. Read
getFinishDate() (set before the finish callback) instead, which also keeps the
extended end controllable in tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): End the extended transaction at the extended span end

When the extended span finished after the timestamp passed to
finishTransaction() but before that call ran (e.g. a synchronous extension in a
headless start, where finishTransaction runs later at main-thread idle),
waitForChildren had nothing left to wait for and the transaction kept the
earlier passed timestamp. The extended span then ended after the transaction,
and the app start vital exceeded the transaction duration. Finish at
max(endTimestamp, extended span finish date) so the span is contained and the
duration matches the vital.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* ref(extend-app-start): Rename extended app start span op to app.start.extended

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Guard extendAppStartListener with the lock

The setter wrote the field without synchronization while extendAppStart()
reads it under the lock, leaving no happens-before edge. Acquire the same
lock in the setter, consistent with the rest of the class's mutable state.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Fix headless app start end time and duplicate txn

Two issues in onHeadlessAppStart for extended starts:
- The extended branch finished the eager transaction but never persisted
  appStartEndTime, leaving the continuation window unbounded so a later
  activity would wrongly continue the stale trace. Persist it on all paths.
- The branch only checked isActive(), so if the extension already finished
  (finishExtendedAppStart or the deadline) before the headless idle ran, a
  second, empty standalone app.start was created. Guard on
  shouldSendStartMeasurements to avoid the duplicate.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim low-value comments in the headless fix

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Drop redundant extend-listener comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim redundant comments in onActivityCreated

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Remove explanatory comments in app start paths

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Consume stored app start trace on the extension path

The first activity continuing an extended app.start did not clear the stored
trace headers (only the headless-follow path did), so a later activity saw
them and wrongly reused the finished app start trace. Clear them on the
extension path too.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Only the launch activity attaches the app start screen

While the extension was open, every activity's onActivityCreated re-attached
app.vitals.start.screen to the eager app.start, so a second activity opened
before finishExtendedAppStart() overwrote the launch screen. Gate the attach
on isAppStart so only the launch activity sets it.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Format code

* Format code

* style(extend-app-start): Trim verbose finishTransaction comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim verbose comments in app start paths

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Read finish date in getExtendedAppStartSpan

Finishing the extended span runs the event processor re-entrantly (via
the waitForChildren transaction) before the span's isFinished() flag is
set, while the finish timestamp is already in place. Reading isFinished()
could therefore hand out a span that is already finishing. Switch to
getFinishDate() == null, matching getExtendedEndTime().

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Trim duplicated reentrancy comment in getExtendedAppStartSpan

Replace the repeated reentrancy explanation with a cross-reference to
getExtendedEndTime(), which holds the canonical version.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Keep trimmed reentrancy comment within line length

Single-line form fits the 100-char limit so spotless leaves it unwrapped.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Drop two line-narrating test comments

Remove comments that restated the adjacent test code (the eager
extendAppStart call and the second-activity open).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* style(extend-app-start): Reword getExtendedAppStartSpan reentrancy comment

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Rename isAppStartWindowOpen to canExtendAppStart

The predicate has a single consumer — the extend gate in
AppStartExtension — so name it for that intent. Also drop the
self-evident max-end comment in finishTransaction. Regenerated apiDump.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop redundant getExtendedAppStartSpan finished test

After getExtendedAppStartSpan switched to getFinishDate(), the
"after the span finished" case exercises the same branch as the
reentrancy test (finishDate set -> NoOp); the isFinished stub was inert.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Drop narrating comments from app start tests

The test names describe the scenarios; the inline comments restated them.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Add setData and isExtended to AppStartExtension

Move these component accessors into the component-extraction PR (they were
introduced later in the wiring PR). Keeps the full AppStartExtension surface
and its unit tests together here; the wiring PR only consumes them. Inert on
its own. Regenerated apiDump.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(extend-app-start): Name app start branching booleans by intent

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(extend-app-start): Make shouldSendStartMeasurements volatile

It is written without a lock in onAppStartSpansSent() and read across threads in canExtendAppStart() (via extendAppStart()), with no happens-before edge. volatile guarantees visibility, matching the AtomicInteger/AtomicBoolean siblings in the same check.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(extend-app-start): Explain why AppStartExtension holds span and transaction

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Return null from getExtendedAppStartSpan when inactive

Mirrors Sentry.getSpan(): the extender reports null when there is no active extended span instead of a NoOpSpan, so callers can tell there is no span running.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Return null from AppStartExtension.getExtendedAppStartSpan when inactive

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(extend-app-start): Assert null extended span now that getExtendedAppStartSpan is nullable

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat(extend-app-start): Make Sentry.getExtendedAppStartSpan() nullable

Mirrors Sentry.getSpan(): returns null when no extension is active instead of a NoOpSpan, so callers can tell there is no span running. Sample null-checks the span.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>

* changelog

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |  13 +
 .../api/sentry-android-core.api               |  26 ++
 .../core/ActivityLifecycleIntegration.java    | 140 ++++++++-
 .../core/AndroidOptionsInitializer.java       |   1 +
 .../android/core/AppStartExtension.java       | 184 +++++++++++
 .../PerformanceAndroidEventProcessor.java     |  53 +++-
 .../core/performance/AppStartMetrics.java     |  29 +-
 .../core/ActivityLifecycleIntegrationTest.kt  | 287 ++++++++++++++++++
 .../android/core/AppStartExtensionTest.kt     | 259 ++++++++++++++++
 .../PerformanceAndroidEventProcessorTest.kt   |  71 +++++
 .../core/performance/AppStartMetricsTest.kt   |  99 ++++++
 .../sentry/samples/android/MyApplication.java |  32 ++
 sentry/api/sentry.api                         |  18 ++
 .../java/io/sentry/IAppStartExtender.java     |  34 +++
 .../java/io/sentry/NoOpAppStartExtender.java  |  28 ++
 sentry/src/main/java/io/sentry/Sentry.java    |  32 ++
 .../main/java/io/sentry/SentryOptions.java    |  19 ++
 .../io/sentry/NoOpAppStartExtenderTest.kt     |  17 ++
 .../test/java/io/sentry/SentryOptionsTest.kt  |  20 ++
 sentry/src/test/java/io/sentry/SentryTest.kt  |  49 +++
 20 files changed, 1383 insertions(+), 28 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/AppStartExtension.java
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/AppStartExtensionTest.kt
 create mode 100644 sentry/src/main/java/io/sentry/IAppStartExtender.java
 create mode 100644 sentry/src/main/java/io/sentry/NoOpAppStartExtender.java
 create mode 100644 sentry/src/test/java/io/sentry/NoOpAppStartExtenderTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 107b916808a..24df41730a5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,19 @@
 
 ### Features
 
+- Add `Sentry.extendAppStart()`, `Sentry.finishExtendedAppStart()`, and `Sentry.getExtendedAppStartSpan()` to extend the app start measurement past the first frame for extra launch-time work on Android ([#5604](https://github.com/getsentry/sentry-java/pull/5604))
+  - Requires standalone app start tracing (`options.isEnableStandaloneAppStartTracing`). Call `extendAppStart()` in `Application.onCreate` after SDK init and `finishExtendedAppStart()` when done:
+
+  ```kotlin
+  Sentry.extendAppStart()
+
+  // Optionally, retrieve the extended app start span to attach your own child spans
+  val child = Sentry.getExtendedAppStartSpan()?.startChild("preload", "Preload resources")
+  // ... extra launch-time work ...
+  child?.finish()
+
+  Sentry.finishExtendedAppStart()
+  ```
 - Add `trace_metric_byte` data category and record byte-level client reports when trace metrics are discarded ([#5626](https://github.com/getsentry/sentry-java/pull/5626))
 - Support the `io.sentry.tombstone.report-historical` manifest option to enable historical tombstone reporting via `AndroidManifest.xml` `<meta-data>` ([#5683](https://github.com/getsentry/sentry-java/pull/5683))
 
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 58325d08b5b..424a283c7d2 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -184,6 +184,30 @@ public final class io/sentry/android/core/AppLifecycleIntegration : io/sentry/In
 	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 
+public final class io/sentry/android/core/AppStartExtension : io/sentry/IAppStartExtender {
+	public fun <init> (Lio/sentry/android/core/performance/AppStartMetrics;)V
+	public fun clear ()V
+	public fun extendAppStart ()V
+	public fun finishExtendedAppStart ()V
+	public fun finishTransaction (Lio/sentry/SentryDate;)V
+	public fun getExtendedAppStartSpan ()Lio/sentry/ISpan;
+	public fun getExtendedEndTime ()Lio/sentry/SentryDate;
+	public fun isActive ()Z
+	public fun isExtended ()Z
+	public fun setData (Ljava/lang/String;Ljava/lang/Object;)V
+	public fun setExtendAppStartListener (Lio/sentry/android/core/AppStartExtension$ExtendAppStartListener;)V
+}
+
+public abstract interface class io/sentry/android/core/AppStartExtension$ExtendAppStartListener {
+	public abstract fun onExtendAppStartRequested ()Lio/sentry/android/core/AppStartExtension$ExtendedAppStart;
+}
+
+public final class io/sentry/android/core/AppStartExtension$ExtendedAppStart {
+	public final field span Lio/sentry/ISpan;
+	public final field transaction Lio/sentry/ITransaction;
+	public fun <init> (Lio/sentry/ITransaction;Lio/sentry/ISpan;)V
+}
+
 public final class io/sentry/android/core/AppState : java/io/Closeable {
 	public fun addAppStateListener (Lio/sentry/android/core/AppState$AppStateListener;)V
 	public fun close ()V
@@ -739,12 +763,14 @@ public class io/sentry/android/core/performance/AppStartMetrics : io/sentry/andr
 	public static final field staticLock Lio/sentry/util/AutoClosableReentrantLock;
 	public fun <init> ()V
 	public fun addActivityLifecycleTimeSpans (Lio/sentry/android/core/performance/ActivityLifecycleTimeSpan;)V
+	public fun canExtendAppStart ()Z
 	public fun clear ()V
 	public fun createProcessInitSpan ()Lio/sentry/android/core/performance/TimeSpan;
 	public fun getActivityLifecycleTimeSpans ()Ljava/util/List;
 	public fun getAppStartBaggageHeader ()Ljava/lang/String;
 	public fun getAppStartContinuousProfiler ()Lio/sentry/IContinuousProfiler;
 	public fun getAppStartEndTime ()Lio/sentry/SentryDate;
+	public fun getAppStartExtension ()Lio/sentry/android/core/AppStartExtension;
 	public fun getAppStartProfiler ()Lio/sentry/ITransactionProfiler;
 	public fun getAppStartReason ()Ljava/lang/String;
 	public fun getAppStartSamplingDecision ()Lio/sentry/TracesSamplingDecision;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
index d70ff837178..f416df6a988 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ActivityLifecycleIntegration.java
@@ -65,6 +65,8 @@ public final class ActivityLifecycleIntegration
   static final String APP_START_COLD = "app.start.cold";
   static final String TTID_OP = "ui.load.initial_display";
   static final String TTFD_OP = "ui.load.full_display";
+  static final String APP_START_EXTENDED_OP = "app.start.extended";
+  static final String APP_START_EXTENDED_DESC = "Extended App Start";
   static final long TTFD_TIMEOUT_MILLIS = 25000;
   // If a headless app start and the following activity's ui.load are more than this far apart, they
   // are treated as unrelated and not connected into the same trace.
@@ -139,7 +141,9 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
     application.registerActivityLifecycleCallbacks(this);
 
     if (performanceEnabled && this.options.isEnableStandaloneAppStartTracing()) {
-      AppStartMetrics.getInstance().setHeadlessAppStartListener(this::onHeadlessAppStart);
+      final @NotNull AppStartMetrics metrics = AppStartMetrics.getInstance();
+      metrics.setHeadlessAppStartListener(this::onHeadlessAppStart);
+      metrics.getAppStartExtension().setExtendAppStartListener(this::onExtendAppStartRequested);
       addIntegrationToSdkVersion("StandaloneAppStart");
     }
 
@@ -154,7 +158,9 @@ private boolean isPerformanceEnabled(final @NotNull SentryAndroidOptions options
   @Override
   public void close() throws IOException {
     application.unregisterActivityLifecycleCallbacks(this);
-    AppStartMetrics.getInstance().setHeadlessAppStartListener(null);
+    final @NotNull AppStartMetrics metrics = AppStartMetrics.getInstance();
+    metrics.setHeadlessAppStartListener(null);
+    metrics.getAppStartExtension().setExtendAppStartListener(null);
 
     if (options != null) {
       options.getLogger().log(SentryLevel.DEBUG, "ActivityLifecycleIntegration removed.");
@@ -259,17 +265,23 @@ private void startTracing(final @NotNull Activity activity) {
         transactionOptions.setAppStartTransaction(appStartSamplingDecision != null);
         setSpanOrigin(transactionOptions);
 
+        // Guards the headless-start check below with !isExtensionActive so the eager extension's
+        // stored trace id isn't mistaken for a finished headless start.
+        final boolean isExtensionActive =
+            AppStartMetrics.getInstance().getAppStartExtension().isActive();
+
         final @Nullable SentryId storedAppStartTraceId =
             AppStartMetrics.getInstance().getAppStartTraceId();
-        final boolean isFollowingHeadlessAppStart = (storedAppStartTraceId != null);
+        final boolean isFollowingHeadlessAppStart =
+            !isExtensionActive && (storedAppStartTraceId != null);
 
         final boolean isAppStart =
             !(firstActivityCreated || appStartTime == null || coldStart == null);
-        // Foreground starts create app.start first; ui.load then shares its trace.
         final boolean createStandaloneAppStart =
             isAppStart
                 && options.isEnableStandaloneAppStartTracing()
-                && !isFollowingHeadlessAppStart;
+                && !isFollowingHeadlessAppStart
+                && !isExtensionActive;
 
         if (createStandaloneAppStart) {
           final TransactionOptions appStartTransactionOptions = new TransactionOptions();
@@ -300,8 +312,8 @@ private void startTracing(final @NotNull Activity activity) {
           continueSentryTrace = appStartTransaction.toSentryTrace().getValue();
           final @Nullable BaggageHeader baggageHeader = appStartTransaction.toBaggageHeader(null);
           continueBaggage = baggageHeader == null ? null : baggageHeader.getValue();
-        } else if (isFollowingHeadlessAppStart
-            && isWithinAppStartContinuationWindow(ttidStartTime)) {
+        } else if (isExtensionActive
+            || (isFollowingHeadlessAppStart && isWithinAppStartContinuationWindow(ttidStartTime))) {
           continueSentryTrace = AppStartMetrics.getInstance().getAppStartSentryTraceHeader();
           continueBaggage = AppStartMetrics.getInstance().getAppStartBaggageHeader();
         } else {
@@ -309,6 +321,14 @@ && isWithinAppStartContinuationWindow(ttidStartTime)) {
           continueBaggage = null;
         }
 
+        if (isExtensionActive && isAppStart) {
+          // Only the launch activity sets the screen, so a later activity can't overwrite it. A
+          // screen also keeps the processor from classifying the eager app.start as headless.
+          AppStartMetrics.getInstance()
+              .getAppStartExtension()
+              .setData(APP_START_SCREEN_DATA, activityName);
+        }
+
         final @Nullable TransactionContext continuedContext =
             continueSentryTrace == null
                 ? null
@@ -328,8 +348,8 @@ && isWithinAppStartContinuationWindow(ttidStartTime)) {
                   transactionOptions);
         }
 
-        if (isFollowingHeadlessAppStart) {
-          // Consume the stored headless app-start trace so it isn't reused by another activity.
+        if (isFollowingHeadlessAppStart || isExtensionActive) {
+          // Consume the stored app-start trace so a later activity doesn't reuse it.
           AppStartMetrics.getInstance().setAppStartTraceId(null);
           AppStartMetrics.getInstance().setAppStartSentryTraceHeader(null);
           AppStartMetrics.getInstance().setAppStartBaggageHeader(null);
@@ -967,6 +987,9 @@ private void finishAppStartSpan(final @Nullable SentryDate endDate) {
       if (appStartTransaction != null && !appStartTransaction.isFinished()) {
         appStartTransaction.finish(SpanStatus.OK, appStartEndTime);
       }
+      // Finish the eager extended transaction at the natural first-frame end. waitForChildren keeps
+      // it open until the extended span finishes; no-op if the app start was not extended.
+      AppStartMetrics.getInstance().getAppStartExtension().finishTransaction(appStartEndTime);
     }
   }
 
@@ -994,17 +1017,60 @@ private void onHeadlessAppStart() {
       return;
     }
 
+    // Persist the end time so a later ui.load can tell whether it is close enough to continue this
+    // trace; without it the continuation window is unbounded.
+    metrics.setAppStartEndTime(endTime);
+
+    final @NotNull AppStartExtension extension = metrics.getAppStartExtension();
+    if (extension.isActive()) {
+      extension.finishTransaction(endTime);
+      return;
+    }
+    if (!metrics.shouldSendStartMeasurements(true)) {
+      return;
+    }
+
+    final @NotNull ITransaction transaction =
+        createStandaloneAppStartTransaction(startTime, null, false);
+    transaction.finish(SpanStatus.OK, endTime);
+  }
+
+  /**
+   * Creates the standalone {@code app.start} transaction (not bound to the scope) and persists its
+   * trace headers so a later {@code ui.load} can share the same trace. Shared by the headless path
+   * and the eager extension path. When {@code holdOpenForExtension} is true, the transaction waits
+   * for its children and gets a deadline so it stays open until the extended span finishes.
+   */
+  private @NotNull ITransaction createStandaloneAppStartTransaction(
+      final @NotNull SentryDate startTime,
+      final @Nullable TracesSamplingDecision samplingDecision,
+      final boolean holdOpenForExtension) {
+    final @NotNull AppStartMetrics metrics = AppStartMetrics.getInstance();
+
     final TransactionOptions txnOptions = new TransactionOptions();
     txnOptions.setBindToScope(false);
     txnOptions.setStartTimestamp(startTime);
     txnOptions.setOrigin(APP_START_TRACE_ORIGIN);
+    txnOptions.setAppStartTransaction(samplingDecision != null);
+    if (holdOpenForExtension) {
+      txnOptions.setWaitForChildren(true);
+      final long deadlineTimeoutMillis = options.getDeadlineTimeout();
+      txnOptions.setDeadlineTimeout(deadlineTimeoutMillis <= 0 ? null : deadlineTimeoutMillis);
+      // Persist the end time (covering every finish path: user finish, first frame, deadline) so a
+      // later ui.load can tell whether it is close enough to continue this trace; without it the
+      // continuation window is unbounded.
+      txnOptions.setTransactionFinishedCallback(
+          finishedTransaction ->
+              AppStartMetrics.getInstance()
+                  .setAppStartEndTime(finishedTransaction.getFinishDate()));
+    }
 
     final @NotNull TransactionContext txnContext =
         new TransactionContext(
             STANDALONE_APP_START_NAME,
             TransactionNameSource.COMPONENT,
             STANDALONE_APP_START_OP,
-            null);
+            samplingDecision);
 
     final @NotNull ITransaction transaction = scopes.startTransaction(txnContext, txnOptions);
     final @Nullable String appStartReason = metrics.getAppStartReason();
@@ -1016,10 +1082,56 @@ private void onHeadlessAppStart() {
     metrics.setAppStartSentryTraceHeader(transaction.toSentryTrace().getValue());
     final @Nullable BaggageHeader baggageHeader = transaction.toBaggageHeader(null);
     metrics.setAppStartBaggageHeader(baggageHeader == null ? null : baggageHeader.getValue());
-    // Persist the end time so a later activity can decide whether its ui.load is close enough in
-    // time to continue this trace.
-    metrics.setAppStartEndTime(endTime);
+    return transaction;
+  }
 
-    transaction.finish(SpanStatus.OK, endTime);
+  /**
+   * Handles {@code Sentry.extendAppStart()}: eagerly creates the standalone app.start transaction
+   * and the extended child span (we have scopes here), then hands both to the {@link
+   * AppStartExtension}, which owns them. The transaction is held open ({@code waitForChildren})
+   * until the user calls {@code Sentry.finishExtendedAppStart()} or the deadline forces it.
+   * Standalone-only: this is only registered as a listener when standalone app start tracing is
+   * enabled.
+   */
+  private @Nullable AppStartExtension.ExtendedAppStart onExtendAppStartRequested() {
+    if (scopes == null
+        || options == null
+        || !performanceEnabled
+        || !options.isEnableStandaloneAppStartTracing()) {
+      return null;
+    }
+    final @NotNull AppStartMetrics metrics = AppStartMetrics.getInstance();
+
+    final @NotNull TimeSpan appStartTimeSpan =
+        metrics.getAppStartTimeSpan().hasStarted()
+            ? metrics.getAppStartTimeSpan()
+            : metrics.getSdkInitTimeSpan();
+    final @Nullable SentryDate startTime = appStartTimeSpan.getStartTimestamp();
+    if (startTime == null) {
+      return null;
+    }
+
+    // The app start sampling decision was pre-rolled on the previous run so the app start
+    // profiler could start before Sentry.init. It forces the trace sampling of the eager
+    // app.start transaction created below (no re-roll, staying consistent with whether the
+    // profiler actually started) and lets it bind the app start profiler. It's single-use:
+    // we clear it so the first ui.load can't also claim it.
+    final @Nullable TracesSamplingDecision samplingDecision = metrics.getAppStartSamplingDecision();
+    metrics.setAppStartSamplingDecision(null);
+
+    final @NotNull ITransaction transaction =
+        createStandaloneAppStartTransaction(startTime, samplingDecision, true);
+
+    final SpanOptions spanOptions = new SpanOptions();
+    setSpanOrigin(spanOptions);
+    final @NotNull ISpan extendedSpan =
+        transaction.startChild(
+            APP_START_EXTENDED_OP,
+            APP_START_EXTENDED_DESC,
+            AndroidDateUtils.getCurrentSentryDateTime(),
+            Instrumenter.SENTRY,
+            spanOptions);
+
+    return new AppStartExtension.ExtendedAppStart(transaction, extendedSpan);
   }
 }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 5704cf7d7d4..9cc5cb3df0f 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -198,6 +198,7 @@ static void initializeIntegrationsAndProcessors(
     }
 
     final @NotNull AppStartMetrics appStartMetrics = AppStartMetrics.getInstance();
+    options.setAppStartExtender(appStartMetrics.getAppStartExtension());
 
     if (options.getModulesLoader() instanceof NoOpModulesLoader) {
       options.setModulesLoader(new AssetsModulesLoader(context, options));
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AppStartExtension.java b/sentry-android-core/src/main/java/io/sentry/android/core/AppStartExtension.java
new file mode 100644
index 00000000000..3583474cfa7
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AppStartExtension.java
@@ -0,0 +1,184 @@
+package io.sentry.android.core;
+
+import io.sentry.IAppStartExtender;
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.ISpan;
+import io.sentry.ITransaction;
+import io.sentry.Sentry;
+import io.sentry.SentryDate;
+import io.sentry.SentryLevel;
+import io.sentry.SpanStatus;
+import io.sentry.android.core.performance.AppStartMetrics;
+import io.sentry.util.AutoClosableReentrantLock;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+public final class AppStartExtension implements IAppStartExtender {
+
+  public static final class ExtendedAppStart {
+    public final @NotNull ITransaction transaction;
+    public final @NotNull ISpan span;
+
+    public ExtendedAppStart(final @NotNull ITransaction transaction, final @NotNull ISpan span) {
+      this.transaction = transaction;
+      this.span = span;
+    }
+  }
+
+  public interface ExtendAppStartListener {
+    @Nullable
+    ExtendedAppStart onExtendAppStartRequested();
+  }
+
+  private final @NotNull AppStartMetrics metrics;
+  private final @NotNull AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
+
+  private @Nullable ExtendAppStartListener extendAppStartListener;
+  // We hold onto both the span and its transaction because they mean different things and finish
+  // at different times:
+  //
+  //  - extendedSpan is what the app developer works with: they get it from
+  //    getExtendedAppStartSpan(), add their own child spans to it, and finish it by calling
+  //    finishExtendedAppStart(). Its end time is what extends the app start measurement.
+  //
+  //  - extendedTransaction is the standalone "app.start" transaction that actually gets sent to
+  //    Sentry. It carries the span and the screen name. The SDK asks it to finish at the first
+  //    frame (or headless end), but because it uses waitForChildren it stays open until the span
+  //    finishes (or the deadline is hit).
+  //
+  // A span doesn't expose its transaction, and pulling the span back out of the transaction would
+  // be fragile, so we just keep a reference to each.
+  private @Nullable ISpan extendedSpan;
+  private @Nullable ITransaction extendedTransaction;
+
+  public AppStartExtension(final @NotNull AppStartMetrics metrics) {
+    this.metrics = metrics;
+  }
+
+  public void setExtendAppStartListener(final @Nullable ExtendAppStartListener listener) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      this.extendAppStartListener = listener;
+    }
+  }
+
+  @Override
+  public void extendAppStart() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      if (extendedSpan != null) {
+        Sentry.getCurrentScopes()
+            .getOptions()
+            .getLogger()
+            .log(SentryLevel.WARNING, "App start is already being extended.");
+        return;
+      }
+      if (!metrics.canExtendAppStart()) {
+        Sentry.getCurrentScopes()
+            .getOptions()
+            .getLogger()
+            .log(
+                SentryLevel.WARNING,
+                "Cannot extend app start: the app start window has already passed.");
+        return;
+      }
+      final @Nullable ExtendAppStartListener listener = extendAppStartListener;
+      if (listener != null) {
+        final @Nullable ExtendedAppStart extended = listener.onExtendAppStartRequested();
+        if (extended != null) {
+          this.extendedTransaction = extended.transaction;
+          this.extendedSpan = extended.span;
+        }
+      }
+    }
+  }
+
+  /**
+   * Sets data on the owned (eager) transaction if it is still open. Used to attach the screen name
+   * once the first activity is known, since the transaction is created in {@code onCreate} before
+   * any activity exists.
+   */
+  public void setData(final @NotNull String key, final @Nullable Object value) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      if (extendedTransaction != null && !extendedTransaction.isFinished()) {
+        extendedTransaction.setData(key, value);
+      }
+    }
+  }
+
+  @Override
+  public void finishExtendedAppStart() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      final @Nullable ISpan span = extendedSpan;
+      if (span != null && !span.isFinished()) {
+        span.finish(SpanStatus.OK);
+      }
+    }
+  }
+
+  @Override
+  public @Nullable ISpan getExtendedAppStartSpan() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      final @Nullable ISpan span = extendedSpan;
+      // Mirrors getExtendedEndTime(): the finish date is set before isFinished() flips.
+      if (span != null && span.getFinishDate() == null) {
+        return span;
+      }
+      return null;
+    }
+  }
+
+  public boolean isActive() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return extendedTransaction != null && !extendedTransaction.isFinished();
+    }
+  }
+
+  /**
+   * Whether this app start was extended at all, regardless of finish or deadline state. Used by the
+   * event processor to decide whether to apply the never-shorten vital logic.
+   */
+  public boolean isExtended() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return extendedSpan != null;
+    }
+  }
+
+  public void finishTransaction(final @NotNull SentryDate endTimestamp) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      final @Nullable ITransaction transaction = extendedTransaction;
+      if (transaction != null && !transaction.isFinished()) {
+        final @Nullable ISpan span = extendedSpan;
+        final @Nullable SentryDate spanEnd = span == null ? null : span.getFinishDate();
+        final @NotNull SentryDate end =
+            spanEnd != null && spanEnd.isAfter(endTimestamp) ? spanEnd : endTimestamp;
+        transaction.finish(SpanStatus.OK, end);
+      }
+    }
+  }
+
+  public @Nullable SentryDate getExtendedEndTime() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      final @Nullable ISpan span = extendedSpan;
+      if (span == null) {
+        return null;
+      }
+      // A deadline timeout would report an artificially inflated duration; suppress the vital
+      // instead.
+      if (span.getStatus() == SpanStatus.DEADLINE_EXCEEDED) {
+        return null;
+      }
+      // Read the finish date, not isFinished(): finishing the extended span completes the
+      // waitForChildren transaction and runs the event processor re-entrantly before the span's
+      // finished flag is set, but the finish timestamp is already in place. Null until finished.
+      return span.getFinishDate();
+    }
+  }
+
+  public void clear() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      extendedSpan = null;
+      extendedTransaction = null;
+    }
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java
index 0b50b5080f4..d758470baf7 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerformanceAndroidEventProcessor.java
@@ -10,6 +10,7 @@
 import io.sentry.Hint;
 import io.sentry.ISentryLifecycleToken;
 import io.sentry.MeasurementUnit;
+import io.sentry.SentryDate;
 import io.sentry.SentryEvent;
 import io.sentry.SpanContext;
 import io.sentry.SpanDataConvention;
@@ -29,6 +30,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -101,20 +103,49 @@ public SentryEvent process(@NotNull SentryEvent event, @NotNull Hint hint) {
               isHeadlessStandaloneAppStartTxn
                   ? appStartMetrics.getAppStartTimeSpanForHeadless()
                   : appStartMetrics.getAppStartTimeSpanWithFallback(options);
-          final long appStartUpDurationMs = appStartTimeSpan.getDurationMs();
+          final long naturalDurationMs = appStartTimeSpan.getDurationMs();
+
+          final long appStartUpDurationMs;
+          final boolean shouldAttachAppStartSpans;
+          final boolean reportAppStartMeasurement;
+          final @NotNull AppStartExtension extension = appStartMetrics.getAppStartExtension();
+          if (extension.isExtended()) {
+            final @Nullable SentryDate extendedEnd = extension.getExtendedEndTime();
+            if (extendedEnd != null && appStartTimeSpan.hasStarted()) {
+              // Measure to the extended end, but never shorter than the natural first-frame
+              // duration.
+              final long extendedDurationMs =
+                  TimeUnit.NANOSECONDS.toMillis(extendedEnd.nanoTimestamp())
+                      - appStartTimeSpan.getStartTimestampMs();
+              appStartUpDurationMs = Math.max(naturalDurationMs, extendedDurationMs);
+              shouldAttachAppStartSpans = appStartUpDurationMs != 0;
+              reportAppStartMeasurement = shouldAttachAppStartSpans;
+            } else {
+              // Deadline (null) or no valid start: attach the spans but suppress the measurement so
+              // it isn't inflated.
+              appStartUpDurationMs = 0;
+              shouldAttachAppStartSpans = appStartTimeSpan.hasStarted();
+              reportAppStartMeasurement = false;
+            }
+          } else {
+            appStartUpDurationMs = naturalDurationMs;
+            shouldAttachAppStartSpans = appStartUpDurationMs != 0;
+            reportAppStartMeasurement = shouldAttachAppStartSpans;
+          }
 
-          // if appStartUpDurationMs is 0, metrics are not ready to be sent
-          if (appStartUpDurationMs != 0) {
-            final MeasurementValue value =
-                new MeasurementValue(
-                    (float) appStartUpDurationMs, MeasurementUnit.Duration.MILLISECOND.apiName());
+          if (shouldAttachAppStartSpans) {
+            if (reportAppStartMeasurement) {
+              final MeasurementValue value =
+                  new MeasurementValue(
+                      (float) appStartUpDurationMs, MeasurementUnit.Duration.MILLISECOND.apiName());
 
-            final String appStartKey =
-                appStartMetrics.getAppStartType() == AppStartMetrics.AppStartType.COLD
-                    ? MeasurementValue.KEY_APP_START_COLD
-                    : MeasurementValue.KEY_APP_START_WARM;
+              final String appStartKey =
+                  appStartMetrics.getAppStartType() == AppStartMetrics.AppStartType.COLD
+                      ? MeasurementValue.KEY_APP_START_COLD
+                      : MeasurementValue.KEY_APP_START_WARM;
 
-            transaction.getMeasurements().put(appStartKey, value);
+              transaction.getMeasurements().put(appStartKey, value);
+            }
 
             attachAppStartSpans(appStartMetrics, transaction);
             appStartMetrics.onAppStartSpansSent();
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
index 828e103e8b6..0f4b646856a 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
@@ -21,6 +21,7 @@
 import io.sentry.NoOpLogger;
 import io.sentry.SentryDate;
 import io.sentry.TracesSamplingDecision;
+import io.sentry.android.core.AppStartExtension;
 import io.sentry.android.core.BuildInfoProvider;
 import io.sentry.android.core.ContextUtils;
 import io.sentry.android.core.CurrentActivityHolder;
@@ -87,7 +88,7 @@ public enum AppStartType {
   private @Nullable IContinuousProfiler appStartContinuousProfiler = null;
   private @Nullable TracesSamplingDecision appStartSamplingDecision = null;
   private boolean isCallbackRegistered = false;
-  private boolean shouldSendStartMeasurements = true;
+  private volatile boolean shouldSendStartMeasurements = true;
   private final AtomicInteger activeActivitiesCounter = new AtomicInteger();
   private final AtomicBoolean firstDrawDone = new AtomicBoolean(false);
   private final AtomicBoolean headlessAppStartCheckPending = new AtomicBoolean(false);
@@ -99,6 +100,7 @@ public enum AppStartType {
   private @Nullable String appStartBaggageHeader;
   private @Nullable SentryDate appStartEndTime;
   private @Nullable ApplicationStartInfo cachedStartInfo;
+  private final @NotNull AppStartExtension appStartExtension = new AppStartExtension(this);
 
   public static @NotNull AppStartMetrics getInstance() {
     if (instance == null) {
@@ -282,6 +284,7 @@ public void onAppStartSpansSent() {
     shouldSendStartMeasurements = false;
     contentProviderOnCreates.clear();
     activityLifecycles.clear();
+    appStartExtension.clear();
   }
 
   public boolean shouldSendStartMeasurements(final boolean ignoreForegroundCheck) {
@@ -337,6 +340,21 @@ public long getClassLoadedUptimeMs() {
     return new TimeSpan();
   }
 
+  public @NotNull AppStartExtension getAppStartExtension() {
+    return appStartExtension;
+  }
+
+  /**
+   * Whether the app start can still be extended: measurements haven't been sent yet, no activity
+   * has been created, and the first frame hasn't been drawn. The foreground check is ignored so
+   * headless app starts (broadcast/service) can also be extended.
+   */
+  public boolean canExtendAppStart() {
+    return shouldSendStartMeasurements(true)
+        && activeActivitiesCounter.get() == 0
+        && !firstDrawDone.get();
+  }
+
   @TestOnly
   void setFirstIdle(final long firstIdle) {
     this.firstIdle = firstIdle;
@@ -378,6 +396,7 @@ public void clear() {
     appStartBaggageHeader = null;
     appStartEndTime = null;
     cachedStartInfo = null;
+    appStartExtension.clear();
   }
 
   public @Nullable ITransactionProfiler getAppStartProfiler() {
@@ -624,8 +643,12 @@ public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle saved
       // NOTE: meaningless in standalone app start mode, where a headless start is already its own
       // standalone transaction and therefore cannot be re-classified as warm.
       final long durationSinceAppStartMillis = nowUptimeMs - appStartSpan.getStartUptimeMs();
-      if (!appLaunchedInForeground.getValue()
-          || durationSinceAppStartMillis > TimeUnit.MINUTES.toMillis(1)) {
+      // An active extension explicitly keeps the launch alive: resetting the span here would make
+      // the extended vital measure from the activity while the eager app.start transaction stays
+      // anchored at process start.
+      if ((!appLaunchedInForeground.getValue()
+              || durationSinceAppStartMillis > TimeUnit.MINUTES.toMillis(1))
+          && !appStartExtension.isActive()) {
         appStartType = AppStartType.WARM;
         shouldSendStartMeasurements = true;
         appStartSpan.reset();
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
index 8b842a0cfa9..d198c8d975e 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
@@ -323,6 +323,291 @@ class ActivityLifecycleIntegrationTest {
     assertNull(appStartTransaction.getData("app.vitals.start.reason"))
   }
 
+  @Test
+  fun `extendAppStart eagerly creates a standalone app start transaction with the extended span`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+
+    val appStartTransaction =
+      fixture.createdTransactions.single {
+        it.spanContext.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+      }
+    assertTrue(
+      appStartTransaction.children.any {
+        it.operation == ActivityLifecycleIntegration.APP_START_EXTENDED_OP
+      }
+    )
+    assertTrue(AppStartMetrics.getInstance().appStartExtension.isActive)
+    assertNotNull(AppStartMetrics.getInstance().appStartExtension.extendedAppStartSpan)
+  }
+
+  @Test
+  fun `extended app start continues the trace into ui load without a second app start transaction`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val appStartTransactions =
+      fixture.createdTransactions.filter {
+        it.spanContext.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+      }
+    assertEquals(1, appStartTransactions.size)
+    assertEquals("Activity", appStartTransactions.single().getData("app.vitals.start.screen"))
+    val uiLoadTransaction =
+      fixture.createdTransactions.single {
+        it.spanContext.operation == ActivityLifecycleIntegration.UI_LOAD_OP
+      }
+    assertEquals(
+      appStartTransactions.single().spanContext.traceId,
+      uiLoadTransaction.spanContext.traceId,
+    )
+  }
+
+  @Test
+  fun `extended app start trace is not reused by a later activity`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+
+    val firstActivity = mock<Activity>()
+    sut.onActivityCreated(firstActivity, fixture.bundle)
+    val appStartTraceId =
+      fixture.createdTransactions
+        .single { it.spanContext.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP }
+        .spanContext
+        .traceId
+
+    AppStartMetrics.getInstance().appStartExtension.finishExtendedAppStart()
+    AppStartMetrics.getInstance().onAppStartSpansSent()
+
+    val secondActivity = mock<Activity>()
+    sut.onActivityPaused(firstActivity)
+    sut.onActivityCreated(secondActivity, fixture.bundle)
+
+    assertNotEquals(appStartTraceId, fixture.createdTransactions.last().spanContext.traceId)
+  }
+
+  @Test
+  fun `extended app start screen is not overwritten by a later activity`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+
+    val firstActivity = mock<Activity>()
+    sut.onActivityCreated(firstActivity, fixture.bundle)
+
+    sut.onActivityPaused(firstActivity)
+    sut.onActivityCreated(mock<SecondAppStartActivity>(), fixture.bundle)
+
+    val appStart =
+      fixture.createdTransactions.single {
+        it.spanContext.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+      }
+    assertEquals("Activity", appStart.getData("app.vitals.start.screen"))
+  }
+
+  @Test
+  fun `extended standalone app start transaction stays open until finishExtendedAppStart`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val appStartTransaction =
+      fixture.createdTransactions.single {
+        it.spanContext.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+      }
+
+    appStartTransaction.finish(SpanStatus.OK)
+    assertFalse(appStartTransaction.isFinished)
+
+    AppStartMetrics.getInstance().appStartExtension.finishExtendedAppStart()
+    assertTrue(appStartTransaction.isFinished)
+  }
+
+  @Test
+  fun `extended headless app start transaction stays open until finishExtendedAppStart`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    prepareHeadlessAppStart(appStartType = AppStartType.COLD)
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+
+    driveHeadlessAppStart()
+
+    val transaction = fixture.createdTransactions.single()
+    assertTrue(
+      transaction.children.any {
+        it.operation == ActivityLifecycleIntegration.APP_START_EXTENDED_OP
+      }
+    )
+    assertFalse(transaction.isFinished)
+
+    AppStartMetrics.getInstance().appStartExtension.finishExtendedAppStart()
+    assertTrue(transaction.isFinished)
+  }
+
+  @Test
+  fun `extended headless app start persists the app start end time`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    prepareHeadlessAppStart(appStartType = AppStartType.COLD)
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+
+    driveHeadlessAppStart()
+
+    assertNotNull(AppStartMetrics.getInstance().getAppStartEndTime())
+  }
+
+  @Test
+  fun `finished eager extended app start persists the app start end time`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+    assertNull(AppStartMetrics.getInstance().getAppStartEndTime())
+
+    AppStartMetrics.getInstance().appStartExtension.finishTransaction(SentryNanotimeDate())
+    AppStartMetrics.getInstance().appStartExtension.finishExtendedAppStart()
+
+    assertNotNull(AppStartMetrics.getInstance().getAppStartEndTime())
+  }
+
+  @Test
+  fun `activity long after the eager extended app start finished starts a fresh trace`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    // the eager extension starts at launch and finishes before any activity exists
+    setAppStartTime(date = SentryNanotimeDate(1, 0))
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+    val appStartTraceId = fixture.capturedContexts.single().traceId
+    AppStartMetrics.getInstance()
+      .appStartExtension
+      .extendedAppStartSpan!!
+      .finish(SpanStatus.OK, SentryNanotimeDate(2, 0))
+    AppStartMetrics.getInstance().appStartExtension.finishTransaction(SentryNanotimeDate(2, 0))
+
+    // the first activity opens more than a minute after the extension finished
+    setAppStartTime(date = SentryNanotimeDate(TimeUnit.MINUTES.toMillis(2), 0))
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+
+    val uiLoadContext =
+      fixture.capturedContexts.last { it.operation == ActivityLifecycleIntegration.UI_LOAD_OP }
+    // too far apart: the ui.load gets its own fresh trace, not the finished app.start one
+    assertNotEquals(appStartTraceId, uiLoadContext.traceId)
+    // stored continuation state is still consumed so nothing reuses it
+    assertNull(AppStartMetrics.getInstance().getAppStartTraceId())
+  }
+
+  @Test
+  fun `extended headless app start does not create a duplicate when the extension already finished`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    prepareHeadlessAppStart(appStartType = AppStartType.COLD)
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+    AppStartMetrics.getInstance().appStartExtension.finishExtendedAppStart()
+    AppStartMetrics.getInstance().onAppStartSpansSent()
+    val transactionsBefore = fixture.createdTransactions.size
+
+    driveHeadlessAppStart()
+
+    assertEquals(transactionsBefore, fixture.createdTransactions.size)
+  }
+
+  @Test
+  fun `extendAppStart is a no-op when standalone tracing is disabled`() {
+    val sut = fixture.getSut { it.tracesSampleRate = 1.0 }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+
+    assertFalse(AppStartMetrics.getInstance().appStartExtension.isActive)
+    assertNull(AppStartMetrics.getInstance().appStartExtension.extendedAppStartSpan)
+    verify(fixture.scopes, never()).startTransaction(any(), any<TransactionOptions>())
+  }
+
+  @Test
+  fun `extended app start transaction is owned by the extension and survives activity destroy`() {
+    val sut =
+      fixture.getSut {
+        it.tracesSampleRate = 1.0
+        it.isEnableStandaloneAppStartTracing = true
+      }
+    sut.register(fixture.scopes, fixture.options)
+
+    setAppStartTime()
+    AppStartMetrics.getInstance().appStartExtension.extendAppStart()
+
+    val activity = mock<Activity>()
+    sut.onActivityCreated(activity, fixture.bundle)
+    assertTrue(AppStartMetrics.getInstance().appStartExtension.isActive)
+
+    sut.onActivityDestroyed(activity)
+    assertTrue(AppStartMetrics.getInstance().appStartExtension.isActive)
+  }
+
   @Test
   @Config(sdk = [Build.VERSION_CODES.VANILLA_ICE_CREAM])
   fun `Headless standalone app start transaction carries app start reason when available`() {
@@ -2384,3 +2669,5 @@ class ActivityLifecycleIntegrationTest {
     }
   }
 }
+
+private open class SecondAppStartActivity : Activity()
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AppStartExtensionTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AppStartExtensionTest.kt
new file mode 100644
index 00000000000..7fbbca4a3a5
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AppStartExtensionTest.kt
@@ -0,0 +1,259 @@
+package io.sentry.android.core
+
+import android.os.Build
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.ISpan
+import io.sentry.ITransaction
+import io.sentry.SentryLongDate
+import io.sentry.SentryNanotimeDate
+import io.sentry.SpanStatus
+import io.sentry.android.core.performance.AppStartMetrics
+import java.util.concurrent.atomic.AtomicInteger
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertSame
+import kotlin.test.assertTrue
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [Build.VERSION_CODES.N])
+class AppStartExtensionTest {
+
+  private val metrics = mock<AppStartMetrics>()
+
+  private fun extension(windowOpen: Boolean = true): AppStartExtension {
+    whenever(metrics.canExtendAppStart()).thenReturn(windowOpen)
+    return AppStartExtension(metrics)
+  }
+
+  /** Simulates the integration's listener: hands a transaction + span back to the extension. */
+  private fun AppStartExtension.registerHandOver(
+    txn: ITransaction = mock(),
+    span: ISpan = mock(),
+  ): Pair<ITransaction, ISpan> {
+    setExtendAppStartListener { AppStartExtension.ExtendedAppStart(txn, span) }
+    return txn to span
+  }
+
+  @Test
+  fun `extendAppStart fires the listener when the window is open`() {
+    val ext = extension(windowOpen = true)
+    val calls = AtomicInteger()
+    ext.setExtendAppStartListener {
+      calls.incrementAndGet()
+      null
+    }
+    ext.extendAppStart()
+    assertEquals(1, calls.get())
+  }
+
+  @Test
+  fun `extendAppStart does not fire the listener when the window is closed`() {
+    val ext = extension(windowOpen = false)
+    val calls = AtomicInteger()
+    ext.setExtendAppStartListener {
+      calls.incrementAndGet()
+      null
+    }
+    ext.extendAppStart()
+    assertEquals(0, calls.get())
+  }
+
+  @Test
+  fun `extendAppStart is inert when no listener is registered`() {
+    val ext = extension(windowOpen = true)
+    ext.extendAppStart()
+    assertNull(ext.extendedAppStartSpan)
+    assertFalse(ext.isActive)
+  }
+
+  @Test
+  fun `extendAppStart is ignored when already extending`() {
+    val ext = extension(windowOpen = true)
+    val calls = AtomicInteger()
+    val txn = mock<ITransaction>()
+    val span = mock<ISpan>()
+    ext.setExtendAppStartListener {
+      calls.incrementAndGet()
+      AppStartExtension.ExtendedAppStart(txn, span)
+    }
+    ext.extendAppStart()
+    ext.extendAppStart()
+    assertEquals(1, calls.get())
+  }
+
+  @Test
+  fun `getExtendedAppStartSpan returns null when no extension is active`() {
+    assertNull(extension().extendedAppStartSpan)
+  }
+
+  @Test
+  fun `getExtendedAppStartSpan returns the span while extending`() {
+    val ext = extension(windowOpen = true)
+    val (_, span) = ext.registerHandOver()
+    ext.extendAppStart()
+    assertSame(span, ext.extendedAppStartSpan)
+  }
+
+  @Test
+  fun `finishExtendedAppStart finishes the extended span`() {
+    val ext = extension(windowOpen = true)
+    val (_, span) = ext.registerHandOver()
+    ext.extendAppStart()
+    ext.finishExtendedAppStart()
+    verify(span).finish(SpanStatus.OK)
+  }
+
+  @Test
+  fun `finishExtendedAppStart does not finish an already finished span`() {
+    val ext = extension(windowOpen = true)
+    val span = mock<ISpan>()
+    whenever(span.isFinished).thenReturn(true)
+    ext.registerHandOver(span = span)
+    ext.extendAppStart()
+    ext.finishExtendedAppStart()
+    verify(span, never()).finish(any<SpanStatus>())
+  }
+
+  @Test
+  fun `isActive reflects the transaction state`() {
+    val ext = extension(windowOpen = true)
+    assertFalse(ext.isActive)
+    val (txn, _) = ext.registerHandOver()
+    ext.extendAppStart()
+    assertTrue(ext.isActive)
+    whenever(txn.isFinished).thenReturn(true)
+    assertFalse(ext.isActive)
+  }
+
+  @Test
+  fun `isExtended stays true once extended, even after the transaction finishes`() {
+    val ext = extension(windowOpen = true)
+    assertFalse(ext.isExtended)
+    val (txn, _) = ext.registerHandOver()
+    ext.extendAppStart()
+    assertTrue(ext.isExtended)
+    whenever(txn.isFinished).thenReturn(true)
+    assertFalse(ext.isActive)
+    assertTrue(ext.isExtended)
+  }
+
+  @Test
+  fun `finishTransaction finishes the transaction at the given timestamp`() {
+    val ext = extension(windowOpen = true)
+    val (txn, _) = ext.registerHandOver()
+    ext.extendAppStart()
+    val endTimestamp = SentryNanotimeDate()
+    ext.finishTransaction(endTimestamp)
+    verify(txn).finish(SpanStatus.OK, endTimestamp)
+  }
+
+  @Test
+  fun `finishTransaction does not finish an already finished transaction`() {
+    val ext = extension(windowOpen = true)
+    val txn = mock<ITransaction>()
+    whenever(txn.isFinished).thenReturn(true)
+    ext.registerHandOver(txn = txn)
+    ext.extendAppStart()
+    ext.finishTransaction(SentryNanotimeDate())
+    verify(txn, never()).finish(any<SpanStatus>(), any())
+  }
+
+  @Test
+  fun `finishTransaction ends at the extended span end when it finished after the given timestamp`() {
+    // Headless: the extended span can finish (in onCreate) before finishTransaction runs (at idle)
+    // with a finish date later than the headless end. The transaction must end there so it contains
+    // the extended span and its duration matches the app start vital.
+    val ext = extension(windowOpen = true)
+    val txn = mock<ITransaction>()
+    val span = mock<ISpan>()
+    val spanEnd = SentryLongDate(2_000_000_000L)
+    whenever(span.finishDate).thenReturn(spanEnd)
+    ext.registerHandOver(txn = txn, span = span)
+    ext.extendAppStart()
+    ext.finishTransaction(SentryLongDate(1_000_000_000L))
+    verify(txn).finish(SpanStatus.OK, spanEnd)
+  }
+
+  @Test
+  fun `getExtendedEndTime is null while the span is unfinished`() {
+    val ext = extension(windowOpen = true)
+    ext.registerHandOver()
+    ext.extendAppStart()
+    assertNull(ext.extendedEndTime)
+  }
+
+  @Test
+  fun `getExtendedEndTime is null when the extension finished via deadline`() {
+    val ext = extension(windowOpen = true)
+    val span = mock<ISpan>()
+    whenever(span.isFinished).thenReturn(true)
+    whenever(span.status).thenReturn(SpanStatus.DEADLINE_EXCEEDED)
+    whenever(span.finishDate).thenReturn(SentryNanotimeDate())
+    ext.registerHandOver(span = span)
+    ext.extendAppStart()
+    assertNull(ext.extendedEndTime)
+  }
+
+  @Test
+  fun `getExtendedEndTime returns the finish date on a user finish`() {
+    val ext = extension(windowOpen = true)
+    val finishDate = SentryNanotimeDate()
+    val span = mock<ISpan>()
+    whenever(span.isFinished).thenReturn(true)
+    whenever(span.status).thenReturn(SpanStatus.OK)
+    whenever(span.finishDate).thenReturn(finishDate)
+    ext.registerHandOver(span = span)
+    ext.extendAppStart()
+    assertSame(finishDate, ext.extendedEndTime)
+  }
+
+  @Test
+  fun `getExtendedEndTime returns the finish date even when the span still reports unfinished`() {
+    // Reproduces the waitForChildren reentrancy: finishing the extended span completes the
+    // transaction and runs the event processor before the span's isFinished() flips, while the
+    // finish timestamp is already set. getExtendedEndTime() must read the finish date, not the
+    // flag.
+    val ext = extension(windowOpen = true)
+    val finishDate = SentryNanotimeDate()
+    val span = mock<ISpan>()
+    whenever(span.isFinished).thenReturn(false)
+    whenever(span.status).thenReturn(SpanStatus.OK)
+    whenever(span.finishDate).thenReturn(finishDate)
+    ext.registerHandOver(span = span)
+    ext.extendAppStart()
+    assertSame(finishDate, ext.extendedEndTime)
+  }
+
+  @Test
+  fun `clear clears the extension state`() {
+    val ext = extension(windowOpen = true)
+    ext.registerHandOver()
+    ext.extendAppStart()
+    assertTrue(ext.isActive)
+    ext.clear()
+    assertFalse(ext.isActive)
+    assertNull(ext.extendedAppStartSpan)
+  }
+
+  @Test
+  fun `getExtendedAppStartSpan returns null once the finish date is set even if still unfinished`() {
+    // Same waitForChildren reentrancy as getExtendedEndTime: the finish timestamp is set before the
+    // span's isFinished() flips, so the span must not be handed out for new children anymore.
+    val ext = extension(windowOpen = true)
+    val span = mock<ISpan>()
+    whenever(span.isFinished).thenReturn(false)
+    whenever(span.finishDate).thenReturn(SentryNanotimeDate())
+    ext.registerHandOver(span = span)
+    ext.extendAppStart()
+    assertNull(ext.extendedAppStartSpan)
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/PerformanceAndroidEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/PerformanceAndroidEventProcessorTest.kt
index 173b4e3d999..1dc00f09f95 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/PerformanceAndroidEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/PerformanceAndroidEventProcessorTest.kt
@@ -4,7 +4,10 @@ import android.content.ContentProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.Hint
 import io.sentry.IScopes
+import io.sentry.ISpan
+import io.sentry.ITransaction
 import io.sentry.MeasurementUnit
+import io.sentry.SentryLongDate
 import io.sentry.SentryTracer
 import io.sentry.SpanContext
 import io.sentry.SpanDataConvention
@@ -192,6 +195,74 @@ class PerformanceAndroidEventProcessorTest {
     assertEquals(20f, tr.measurements[MeasurementValue.KEY_APP_START_COLD]?.value)
   }
 
+  private fun extendAppStartFinishedWith(status: SpanStatus, endMs: Long) {
+    val span = mock<ISpan>()
+    whenever(span.isFinished).thenReturn(true)
+    whenever(span.status).thenReturn(status)
+    whenever(span.finishDate).thenReturn(SentryLongDate(endMs * 1_000_000L))
+    val ext = AppStartMetrics.getInstance().appStartExtension
+    ext.setExtendAppStartListener { AppStartExtension.ExtendedAppStart(mock<ITransaction>(), span) }
+    ext.extendAppStart()
+  }
+
+  @Test
+  fun `extended app start uses the extended end for the cold start measurement`() {
+    val sut = fixture.getSut(enablePerformanceV2 = true)
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartType = AppStartType.COLD
+    metrics.isAppLaunchedInForeground = true
+    metrics.appStartTimeSpan.apply {
+      setStartedAt(1)
+      setStoppedAt(100)
+    }
+    val startMs = metrics.appStartTimeSpan.startTimestampMs
+    extendAppStartFinishedWith(SpanStatus.OK, startMs + 500)
+
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
+    tr = sut.process(tr, Hint())
+
+    assertEquals(500f, tr.measurements[MeasurementValue.KEY_APP_START_COLD]?.value)
+  }
+
+  @Test
+  fun `extended app start never reports shorter than the natural first frame duration`() {
+    val sut = fixture.getSut(enablePerformanceV2 = true)
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartType = AppStartType.COLD
+    metrics.isAppLaunchedInForeground = true
+    metrics.appStartTimeSpan.apply {
+      setStartedAt(1)
+      setStoppedAt(1000)
+    }
+    val startMs = metrics.appStartTimeSpan.startTimestampMs
+    extendAppStartFinishedWith(SpanStatus.OK, startMs + 100)
+
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
+    tr = sut.process(tr, Hint())
+
+    assertEquals(999f, tr.measurements[MeasurementValue.KEY_APP_START_COLD]?.value)
+  }
+
+  @Test
+  fun `extended app start that hit the deadline suppresses the measurement`() {
+    val sut = fixture.getSut(enablePerformanceV2 = true)
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartType = AppStartType.COLD
+    metrics.isAppLaunchedInForeground = true
+    metrics.appStartTimeSpan.apply {
+      setStartedAt(1)
+      setStoppedAt(100)
+    }
+    val startMs = metrics.appStartTimeSpan.startTimestampMs
+    extendAppStartFinishedWith(SpanStatus.DEADLINE_EXCEEDED, startMs + 30_000)
+
+    var tr = createUiLoadTransactionWithAppStartChildSpan()
+    tr = sut.process(tr, Hint())
+
+    assertFalse(tr.measurements.containsKey(MeasurementValue.KEY_APP_START_COLD))
+    assertFalse(tr.measurements.containsKey(MeasurementValue.KEY_APP_START_WARM))
+  }
+
   @Test
   fun `add cold start measurement for performance-v2`() {
     val sut = fixture.getSut(enablePerformanceV2 = true)
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
index 2737785349f..edf72655740 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
@@ -11,8 +11,10 @@ import android.os.SystemClock
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.DateUtils
 import io.sentry.IContinuousProfiler
+import io.sentry.ITransaction
 import io.sentry.ITransactionProfiler
 import io.sentry.SentryNanotimeDate
+import io.sentry.android.core.AppStartExtension
 import io.sentry.android.core.ContextUtils
 import io.sentry.android.core.CurrentActivityHolder
 import io.sentry.android.core.SentryAndroidOptions
@@ -1024,4 +1026,101 @@ class AppStartMetricsTest {
 
     assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
   }
+
+  @Test
+  fun `canExtendAppStart is true on a fresh foreground start`() {
+    assertTrue(AppStartMetrics.getInstance().canExtendAppStart())
+  }
+
+  @Test
+  fun `canExtendAppStart is true for a headless (non-foreground) start`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.isAppLaunchedInForeground = false
+    assertTrue(metrics.canExtendAppStart())
+  }
+
+  @Test
+  fun `canExtendAppStart is false once an activity was created`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.onActivityCreated(mock(), null)
+    assertFalse(metrics.canExtendAppStart())
+  }
+
+  @Test
+  fun `canExtendAppStart is false once the first frame was drawn`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.onFirstFrameDrawn()
+    assertFalse(metrics.canExtendAppStart())
+  }
+
+  @Test
+  fun `canExtendAppStart is false once start measurements were sent`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.onAppStartSpansSent()
+    assertFalse(metrics.canExtendAppStart())
+  }
+
+  /** Drives the singleton's eager extension into the active state via the listener path. */
+  private fun activateExtension(metrics: AppStartMetrics) {
+    metrics.appStartExtension.setExtendAppStartListener {
+      AppStartExtension.ExtendedAppStart(mock(), mock())
+    }
+    metrics.appStartExtension.extendAppStart()
+    assertTrue(metrics.appStartExtension.isActive)
+  }
+
+  @Test
+  fun `clear resets the extension state`() {
+    val metrics = AppStartMetrics.getInstance()
+    activateExtension(metrics)
+    metrics.clear()
+    assertFalse(metrics.appStartExtension.isActive)
+    metrics.appStartExtension.setExtendAppStartListener(null)
+  }
+
+  @Test
+  fun `onAppStartSpansSent resets the extension state`() {
+    val metrics = AppStartMetrics.getInstance()
+    activateExtension(metrics)
+    metrics.onAppStartSpansSent()
+    assertFalse(metrics.appStartExtension.isActive)
+    metrics.appStartExtension.setExtendAppStartListener(null)
+  }
+
+  @Test
+  fun `late first activity does not reset the app start while the extension is active`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartType = AppStartMetrics.AppStartType.COLD
+    metrics.appStartTimeSpan.setStartedAt(1)
+    activateExtension(metrics)
+
+    SystemClock.setCurrentTimeMillis(TimeUnit.MINUTES.toMillis(2))
+    metrics.onActivityCreated(mock<Activity>(), null)
+
+    assertEquals(AppStartMetrics.AppStartType.COLD, metrics.appStartType)
+    assertEquals(1, metrics.appStartTimeSpan.startUptimeMs)
+    metrics.appStartExtension.setExtendAppStartListener(null)
+  }
+
+  @Test
+  fun `late first activity resets the app start once the extension has finished`() {
+    val metrics = AppStartMetrics.getInstance()
+    metrics.appStartType = AppStartMetrics.AppStartType.COLD
+    metrics.appStartTimeSpan.setStartedAt(1)
+    val transaction = mock<ITransaction>()
+    whenever(transaction.isFinished).thenReturn(true)
+    metrics.appStartExtension.setExtendAppStartListener {
+      AppStartExtension.ExtendedAppStart(transaction, mock())
+    }
+    metrics.appStartExtension.extendAppStart()
+    assertFalse(metrics.appStartExtension.isActive)
+
+    val now = TimeUnit.MINUTES.toMillis(2)
+    SystemClock.setCurrentTimeMillis(now)
+    metrics.onActivityCreated(mock<Activity>(), null)
+
+    assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
+    assertEquals(now, metrics.appStartTimeSpan.startUptimeMs)
+    metrics.appStartExtension.setExtendAppStartListener(null)
+  }
 }
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java
index 6df8ede588e..d9d142cfc65 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MyApplication.java
@@ -2,6 +2,7 @@
 
 import android.app.Application;
 import android.os.StrictMode;
+import io.sentry.ISpan;
 import io.sentry.Sentry;
 import io.sentry.samples.android.sqlite.SampleDatabases;
 
@@ -19,6 +20,8 @@ public void onCreate() {
     strictMode();
     super.onCreate();
 
+    extendAppStartExample();
+
     SampleDatabases.INSTANCE.warmUp(this);
 
     // Example how to initialize the SDK manually which allows access to SentryOptions callbacks.
@@ -36,6 +39,35 @@ public void onCreate() {
     //    });
   }
 
+  // Example of extending the app start: launch-time work done here (after the SDK auto-inits) is
+  // included in the app start measurement. Requires standalone app start tracing
+  // (io.sentry.standalone-app-start-tracing.enable in the manifest). The artificial delays stand in
+  // for real launch work, e.g. loading remote config or feature flags before the first screen.
+  private void extendAppStartExample() {
+    Sentry.extendAppStart();
+
+    final ISpan extendedSpan = Sentry.getExtendedAppStartSpan();
+    if (extendedSpan != null) {
+      final ISpan configSpan = extendedSpan.startChild("remote_config", "Load remote config");
+      artificialDelay(200);
+      configSpan.finish();
+
+      final ISpan flagsSpan = extendedSpan.startChild("feature_flags", "Fetch feature flags");
+      artificialDelay(100);
+      flagsSpan.finish();
+    }
+
+    Sentry.finishExtendedAppStart();
+  }
+
+  private static void artificialDelay(final long millis) {
+    try {
+      Thread.sleep(millis);
+    } catch (final InterruptedException e) {
+      Thread.currentThread().interrupt();
+    }
+  }
+
   private void strictMode() {
     //    https://developer.android.com/reference/android/os/StrictMode
     //    StrictMode is a developer tool which detects things you might be doing by accident and
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 09ede4804a3..c0b6fec780c 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -797,6 +797,12 @@ public final class io/sentry/HubScopesWrapper : io/sentry/IHub {
 	public fun withScope (Lio/sentry/ScopeCallback;)V
 }
 
+public abstract interface class io/sentry/IAppStartExtender {
+	public abstract fun extendAppStart ()V
+	public abstract fun finishExtendedAppStart ()V
+	public abstract fun getExtendedAppStartSpan ()Lio/sentry/ISpan;
+}
+
 public abstract interface class io/sentry/IConnectionStatusProvider : java/io/Closeable {
 	public abstract fun addConnectionStatusObserver (Lio/sentry/IConnectionStatusProvider$IConnectionStatusObserver;)Z
 	public abstract fun getConnectionStatus ()Lio/sentry/IConnectionStatusProvider$ConnectionStatus;
@@ -1542,6 +1548,13 @@ public final class io/sentry/MonitorScheduleUnit : java/lang/Enum {
 	public static fun values ()[Lio/sentry/MonitorScheduleUnit;
 }
 
+public final class io/sentry/NoOpAppStartExtender : io/sentry/IAppStartExtender {
+	public fun extendAppStart ()V
+	public fun finishExtendedAppStart ()V
+	public fun getExtendedAppStartSpan ()Lio/sentry/ISpan;
+	public static fun getInstance ()Lio/sentry/NoOpAppStartExtender;
+}
+
 public final class io/sentry/NoOpCompositePerformanceCollector : io/sentry/CompositePerformanceCollector {
 	public fun close ()V
 	public static fun getInstance ()Lio/sentry/NoOpCompositePerformanceCollector;
@@ -2755,7 +2768,9 @@ public final class io/sentry/Sentry {
 	public static fun continueTrace (Ljava/lang/String;Ljava/util/List;)Lio/sentry/TransactionContext;
 	public static fun distribution ()Lio/sentry/IDistributionApi;
 	public static fun endSession ()V
+	public static fun extendAppStart ()V
 	public static fun feedback ()Lio/sentry/IFeedbackApi;
+	public static fun finishExtendedAppStart ()V
 	public static fun flush (J)V
 	public static fun forkedCurrentScope (Ljava/lang/String;)Lio/sentry/IScopes;
 	public static fun forkedRootScopes (Ljava/lang/String;)Lio/sentry/IScopes;
@@ -2764,6 +2779,7 @@ public final class io/sentry/Sentry {
 	public static fun getCurrentHub ()Lio/sentry/IHub;
 	public static fun getCurrentScopes ()Lio/sentry/IScopes;
 	public static fun getCurrentScopes (Z)Lio/sentry/IScopes;
+	public static fun getExtendedAppStartSpan ()Lio/sentry/ISpan;
 	public static fun getGlobalScope ()Lio/sentry/IScope;
 	public static fun getLastEventId ()Lio/sentry/protocol/SentryId;
 	public static fun getSpan ()Lio/sentry/ISpan;
@@ -3602,6 +3618,7 @@ public class io/sentry/SentryOptions {
 	public fun addScopeObserver (Lio/sentry/IScopeObserver;)V
 	public static fun empty ()Lio/sentry/SentryOptions;
 	public fun findPersistingScopeObserver ()Lio/sentry/cache/PersistingScopeObserver;
+	public fun getAppStartExtender ()Lio/sentry/IAppStartExtender;
 	public fun getBackpressureMonitor ()Lio/sentry/backpressure/IBackpressureMonitor;
 	public fun getBeforeBreadcrumb ()Lio/sentry/SentryOptions$BeforeBreadcrumbCallback;
 	public fun getBeforeEnvelopeCallback ()Lio/sentry/SentryOptions$BeforeEnvelopeCallback;
@@ -3748,6 +3765,7 @@ public class io/sentry/SentryOptions {
 	public fun isTraceSampling ()Z
 	public fun isTracingEnabled ()Z
 	public fun merge (Lio/sentry/ExternalOptions;)V
+	public fun setAppStartExtender (Lio/sentry/IAppStartExtender;)V
 	public fun setAttachServerName (Z)V
 	public fun setAttachStacktrace (Z)V
 	public fun setAttachThreads (Z)V
diff --git a/sentry/src/main/java/io/sentry/IAppStartExtender.java b/sentry/src/main/java/io/sentry/IAppStartExtender.java
new file mode 100644
index 00000000000..079fe272d08
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/IAppStartExtender.java
@@ -0,0 +1,34 @@
+package io.sentry;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Bridges the {@code Sentry.extendAppStart()} / {@code Sentry.finishExtendedAppStart()} / {@code
+ * Sentry.getExtendedAppStartSpan()} static API to the Android implementation. The default
+ * implementation ({@link NoOpAppStartExtender}) does nothing, so the API is a no-op on platforms
+ * that don't provide an app start measurement.
+ */
+@ApiStatus.Internal
+public interface IAppStartExtender {
+
+  /**
+   * Begins extending the app start. Intended to be called from {@code Application.onCreate} right
+   * after SDK init. No-ops if the app start already finished, none is in progress, or it was
+   * already extended (first call wins).
+   */
+  void extendAppStart();
+
+  /**
+   * Finishes the extended app start, allowing the app start transaction to complete. No-ops if the
+   * app start was not extended or this was already called.
+   */
+  void finishExtendedAppStart();
+
+  /**
+   * Returns the active extended app start span to attach child spans to, or {@code null} when the
+   * app start is not currently being extended.
+   */
+  @Nullable
+  ISpan getExtendedAppStartSpan();
+}
diff --git a/sentry/src/main/java/io/sentry/NoOpAppStartExtender.java b/sentry/src/main/java/io/sentry/NoOpAppStartExtender.java
new file mode 100644
index 00000000000..b5fe92ba295
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/NoOpAppStartExtender.java
@@ -0,0 +1,28 @@
+package io.sentry;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@ApiStatus.Internal
+public final class NoOpAppStartExtender implements IAppStartExtender {
+
+  private static final @NotNull NoOpAppStartExtender instance = new NoOpAppStartExtender();
+
+  private NoOpAppStartExtender() {}
+
+  public static @NotNull NoOpAppStartExtender getInstance() {
+    return instance;
+  }
+
+  @Override
+  public void extendAppStart() {}
+
+  @Override
+  public void finishExtendedAppStart() {}
+
+  @Override
+  public @Nullable ISpan getExtendedAppStartSpan() {
+    return null;
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index f5397f191ad..275e2a3c614 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -1276,6 +1276,38 @@ public static void reportFullyDisplayed() {
     getCurrentScopes().reportFullyDisplayed();
   }
 
+  /**
+   * Begins extending the app start so launch-time work done after {@code Application.onCreate}
+   * (e.g. loading remote config before the first screen) is included in the app start measurement.
+   *
+   * <p>Intended to be called from {@code Application.onCreate} right after {@code
+   * SentryAndroid.init}. Only effective on Android with standalone app start tracing enabled;
+   * otherwise it is a no-op. Also no-ops if the app start already finished, none is in progress, or
+   * it was already extended (first call wins). Call {@link #finishExtendedAppStart()} once the
+   * extra work is done; if it is never called, the app start transaction is finished by its
+   * deadline and no extended measurement is reported.
+   */
+  public static void extendAppStart() {
+    getCurrentScopes().getOptions().getAppStartExtender().extendAppStart();
+  }
+
+  /**
+   * Finishes the app start extension started by {@link #extendAppStart()}, allowing the app start
+   * transaction to complete. No-ops if the app start was not extended or this was already called.
+   */
+  public static void finishExtendedAppStart() {
+    getCurrentScopes().getOptions().getAppStartExtender().finishExtendedAppStart();
+  }
+
+  /**
+   * Returns the active extended app start span, to attach child spans for the launch-time work
+   * being measured, or {@code null} when no extension is active (e.g. {@link #extendAppStart()} was
+   * not called, the app start window already passed, or standalone app start tracing is disabled).
+   */
+  public static @Nullable ISpan getExtendedAppStartSpan() {
+    return getCurrentScopes().getOptions().getAppStartExtender().getExtendedAppStartSpan();
+  }
+
   /**
    * Configuration options callback
    *
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 8c995001016..3c55f5e1cfa 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -529,6 +529,9 @@ public class SentryOptions {
   private @NotNull FullyDisplayedReporter fullyDisplayedReporter =
       FullyDisplayedReporter.getInstance();
 
+  /** Bridges the app start extension API to the Android implementation. */
+  private @NotNull IAppStartExtender appStartExtender = NoOpAppStartExtender.getInstance();
+
   private @NotNull IConnectionStatusProvider connectionStatusProvider =
       new NoOpConnectionStatusProvider();
 
@@ -2652,6 +2655,22 @@ public void setFullyDisplayedReporter(
     this.fullyDisplayedReporter = fullyDisplayedReporter;
   }
 
+  /**
+   * Gets the app start extender, which bridges the app start extension API to its implementation.
+   *
+   * @return the app start extender.
+   */
+  @ApiStatus.Internal
+  public @NotNull IAppStartExtender getAppStartExtender() {
+    return appStartExtender;
+  }
+
+  @ApiStatus.Internal
+  public void setAppStartExtender(final @Nullable IAppStartExtender appStartExtender) {
+    this.appStartExtender =
+        appStartExtender != null ? appStartExtender : NoOpAppStartExtender.getInstance();
+  }
+
   /**
    * Whether OPTIONS requests should be traced.
    *
diff --git a/sentry/src/test/java/io/sentry/NoOpAppStartExtenderTest.kt b/sentry/src/test/java/io/sentry/NoOpAppStartExtenderTest.kt
new file mode 100644
index 00000000000..db95270ea8f
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/NoOpAppStartExtenderTest.kt
@@ -0,0 +1,17 @@
+package io.sentry
+
+import kotlin.test.Test
+import kotlin.test.assertNull
+
+class NoOpAppStartExtenderTest {
+  private val extender = NoOpAppStartExtender.getInstance()
+
+  @Test fun `extendAppStart does not throw`() = extender.extendAppStart()
+
+  @Test fun `finishExtendedAppStart does not throw`() = extender.finishExtendedAppStart()
+
+  @Test
+  fun `getExtendedAppStartSpan returns null`() {
+    assertNull(extender.extendedAppStartSpan)
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index 75a24dd68df..9402c6fee9b 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -645,6 +645,26 @@ class SentryOptionsTest {
     assertEquals(FullyDisplayedReporter.getInstance(), SentryOptions().fullyDisplayedReporter)
   }
 
+  @Test
+  fun `when options are initialized, appStartExtender defaults to noop`() {
+    assertEquals(NoOpAppStartExtender.getInstance(), SentryOptions().appStartExtender)
+  }
+
+  @Test
+  fun `when appStartExtender is set, it's returned as well`() {
+    val options = SentryOptions()
+    val customExtender =
+      object : IAppStartExtender {
+        override fun extendAppStart() = Unit
+
+        override fun finishExtendedAppStart() = Unit
+
+        override fun getExtendedAppStartSpan(): ISpan = NoOpSpan.getInstance()
+      }
+    options.setAppStartExtender(customExtender)
+    assertEquals(customExtender, options.appStartExtender)
+  }
+
   @Test
   fun `when options are initialized, connectionStatusProvider is not null and default to noop`() {
     assertNotNull(SentryOptions().connectionStatusProvider)
diff --git a/sentry/src/test/java/io/sentry/SentryTest.kt b/sentry/src/test/java/io/sentry/SentryTest.kt
index 4a122f11422..9da52c39b5a 100644
--- a/sentry/src/test/java/io/sentry/SentryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTest.kt
@@ -1768,4 +1768,53 @@ class SentryTest {
     val scopes = Sentry.getCurrentScopes()
     assertFalse(scopes.isNoOp)
   }
+
+  // region app start extension
+
+  private fun initWithExtender(extender: IAppStartExtender) {
+    initForTest {
+      it.dsn = dsn
+      it.setAppStartExtender(extender)
+    }
+  }
+
+  @Test
+  fun `extendAppStart delegates to the app start extender`() {
+    val extender = mock<IAppStartExtender>()
+    initWithExtender(extender)
+
+    Sentry.extendAppStart()
+
+    verify(extender).extendAppStart()
+  }
+
+  @Test
+  fun `finishExtendedAppStart delegates to the app start extender`() {
+    val extender = mock<IAppStartExtender>()
+    initWithExtender(extender)
+
+    Sentry.finishExtendedAppStart()
+
+    verify(extender).finishExtendedAppStart()
+  }
+
+  @Test
+  fun `getExtendedAppStartSpan delegates to the app start extender`() {
+    val span = mock<ISpan>()
+    val extender = mock<IAppStartExtender>()
+    whenever(extender.extendedAppStartSpan).thenReturn(span)
+    initWithExtender(extender)
+
+    assertSame(span, Sentry.getExtendedAppStartSpan())
+  }
+
+  @Test
+  fun `app start extension api is a no-op when the SDK is disabled`() {
+    // beforeTest called Sentry.close(), so the current scopes are NoOp.
+    Sentry.extendAppStart()
+    Sentry.finishExtendedAppStart()
+    assertNull(Sentry.getExtendedAppStartSpan())
+  }
+
+  // endregion
 }

From 69edd7dd0beef3cc8b339496d38ec6f9002a8fc9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 8 Jul 2026 07:03:01 +0000
Subject: [PATCH 279/391] chore(deps): bump actions/setup-java in the
 github-actions group (#5740)

Bumps the github-actions group with 1 update: [actions/setup-java](https://github.com/actions/setup-java).


Updates `actions/setup-java` from 5.4.0 to 5.5.0
- [Release notes](https://github.com/actions/setup-java/releases)
- [Commits](https://github.com/actions/setup-java/compare/1bcf9fb12cf4aa7d266a90ae39939e61372fe520...0f481fcb613427c0f801b606911222b5b6f3083a)

---
updated-dependencies:
- dependency-name: actions/setup-java
  dependency-version: 5.5.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/codeql-analysis.yml               | 2 +-
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 15 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 13809a303a8..1d2a3bbb567 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -33,7 +33,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 2bb7f3191d7..e396ef97175 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -25,7 +25,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 2335ef3e0a9..274232c8131 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -25,7 +25,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index 33a0cc237fc..0604179edda 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -14,7 +14,7 @@ jobs:
         uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
 
       - name: Set up Java
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index 3fc47aa0f6b..e860ef74f14 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -13,7 +13,7 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index be15b66d370..f6de0912fd4 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -14,7 +14,7 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 7780cf63e02..a2728bc9694 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -32,7 +32,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -82,7 +82,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index f79f36618d1..e8e0df16285 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -23,7 +23,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Setup Java Version
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: "temurin"
           java-version: "17"
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 252e7a5a149..6eeaf4e919d 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -30,7 +30,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Set up Java 17
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 9404975a1fc..ed3a72ce7fc 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -27,7 +27,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index eac4a94966c..e1a334e48a2 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -20,7 +20,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index fec0d2a5a7c..2cee0e04441 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index a86600b30d3..e689bc4c0b7 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 799e93fd293..a1da787305c 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 2a05689cf46..b26632f7f65 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -112,7 +112,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@1bcf9fb12cf4aa7d266a90ae39939e61372fe520 # v5
+        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
         with:
           distribution: 'temurin'
           java-version: '17'

From e3bd612b84f35c9392baef297f365c74885a2966 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Wed, 8 Jul 2026 09:42:41 +0200
Subject: [PATCH 280/391] fix(anr): extend main thread detection from thread
 dump (#5733)

* fix(anr): detect main thread when OS names it after the process

On some Android versions/OEMs, AppExitInfo's thread dump names the
main thread after the process name (e.g. 'com.example.app') instead
of 'main'. ThreadDumpParser previously only matched on 'main',
causing the thread to not be flagged as main/crashed and resulting
in ANR events with no usable stack trace.

Pass the process name from ApplicationExitInfo.getProcessName() to
ThreadDumpParser and treat a thread as main if its name equals
'main' OR the process name.

Fixes JAVA-635

Co-Authored-By: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>

* Format code

* ref(anr): Detect main thread via sysTid matching process id

The main thread can be renamed by the OS to the (potentially truncated) process
name, so relying on the process name is fragile. On Linux/Android the main
thread's kernel thread id (sysTid) always equals the process id, so use that as
the authoritative signal instead.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* Simplify changelog entry

* ref(anr): Normalize main thread name and skip threads without a stacktrace

Normalize the main thread's name back to "main" once it is identified (the OS
may have renamed it to the process name), and drop threads that have no
stacktrace as they are not actionable.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* ref(anr): Detect main thread via sysTid and skip stackless threads

Identify the main thread by matching the thread whose kernel thread id (sysTid)
equals the process id, falling back to the conventional "main" thread name, and
skip threads that have no stacktrace as they are not actionable.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* ref(anr): Clean up ThreadDumpParser

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Update CHANGELOG.md

Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>

---------

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 CHANGELOG.md                                  |  2 +
 .../internal/threaddump/ThreadDumpParser.java | 65 +++++++++++++++----
 .../threaddump/ThreadDumpParserTest.kt        | 43 ++++++++++--
 .../resources/thread_dump_no_stacktrace.txt   | 21 ++++++
 .../thread_dump_process_name_main.txt         | 24 +++++++
 5 files changed, 140 insertions(+), 15 deletions(-)
 create mode 100644 sentry-android-core/src/test/resources/thread_dump_no_stacktrace.txt
 create mode 100644 sentry-android-core/src/test/resources/thread_dump_process_name_main.txt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 24df41730a5..e05a7a1af38 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,8 @@
 
 ### Fixes
 
+- Fix main thread identification parsing for ApplicationExitInfo ANRs ([#5733](https://github.com/getsentry/sentry-java/pull/5733))
+- Do not send threads without stacktraces for ApplicationExitInfo ANRs ([#5733](https://github.com/getsentry/sentry-java/pull/5733))
 - Record byte-level client reports when event processors discard logs or trace metrics ([#5718](https://github.com/getsentry/sentry-java/pull/5718))
 - Name the device-info caching thread `SentryDeviceInfoCache` so all threads spawned by the SDK are identifiable ([#5684](https://github.com/getsentry/sentry-java/pull/5684))
 - Apply byte-category rate limits to log and trace metric envelope items ([#5716](https://github.com/getsentry/sentry-java/pull/5716))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ThreadDumpParser.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ThreadDumpParser.java
index f5ce8a745ce..08432d2f41d 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ThreadDumpParser.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/threaddump/ThreadDumpParser.java
@@ -45,6 +45,12 @@ public class ThreadDumpParser {
   private static final Pattern BEGIN_UNMANAGED_NATIVE_THREAD_RE =
       Pattern.compile("\"(.*)\" (.*) ?sysTid=(\\d+)");
 
+  // e.g. "----- pid 12345 at 2024-01-01 10:00:00.000000000+0000 -----"
+  private static final Pattern PID_RE = Pattern.compile("----- pid (\\d+) at .*");
+
+  // e.g. "  | sysTid=12345 nice=-10 cgrp=top-app sched=0/0 handle=0x7deceb74f8"
+  private static final Pattern SYS_TID_RE = Pattern.compile("\\s*\\|\\s*sysTid=(\\d+).*");
+
   // For reference, see native_stack_dump.cc and tombstone_proto_to_text.cpp in Android sources
   // Groups
   // 0:entire regex
@@ -104,6 +110,11 @@ public class ThreadDumpParser {
 
   private final boolean isBackground;
 
+  // the process id parsed from the thread dump header; on Linux/Android the main thread's kernel
+  // thread id (sysTid) always equals the process id, so we use it to reliably detect the main
+  // thread
+  private @Nullable Long processId;
+
   private final @NotNull SentryStackTraceFactory stackTraceFactory;
 
   private final @NotNull Map<String, DebugImage> debugImages;
@@ -139,6 +150,7 @@ public void parse(final @NotNull Lines lines) {
 
     final Matcher beginManagedThreadRe = BEGIN_MANAGED_THREAD_RE.matcher("");
     final Matcher beginUnmanagedNativeThreadRe = BEGIN_UNMANAGED_NATIVE_THREAD_RE.matcher("");
+    final Matcher pidRe = PID_RE.matcher("");
 
     while (lines.hasNext()) {
       final Line line = lines.next();
@@ -156,10 +168,14 @@ public void parse(final @NotNull Lines lines) {
         if (thread != null) {
           threads.add(thread);
         }
+      } else if (matches(pidRe, text)) {
+        processId = getLong(pidRe, 1, null);
       } else {
         artContextParser.parseLine(text);
       }
     }
+
+    markThreads();
   }
 
   private SentryThread parseThread(final @NotNull Lines lines) {
@@ -185,7 +201,11 @@ private SentryThread parseThread(final @NotNull Lines lines) {
         return null;
       }
       sentryThread.setId(tid);
-      sentryThread.setName(beginManagedThreadRe.group(1));
+      final String name = beginManagedThreadRe.group(1);
+      sentryThread.setName(name);
+      if ("main".equals(name)) {
+        sentryThread.setMain(true);
+      }
       final String state = beginManagedThreadRe.group(5);
       // sanitizing thread that have more details after their actual state, e.g.
       // "Native (still starting up)" <- we just need "Native" here
@@ -205,19 +225,18 @@ private SentryThread parseThread(final @NotNull Lines lines) {
       }
       sentryThread.setId(sysTid);
       sentryThread.setName(beginUnmanagedNativeThreadRe.group(1));
-    }
-
-    final String threadName = sentryThread.getName();
-    if (threadName != null) {
-      final boolean isMain = threadName.equals("main");
-      sentryThread.setMain(isMain);
-      // since it's an ANR, the crashed thread will always be main
-      sentryThread.setCrashed(isMain);
-      sentryThread.setCurrent(isMain && !isBackground);
+      if (sysTid.equals(processId)) {
+        sentryThread.setMain(true);
+      }
     }
 
     // thread stacktrace
     final SentryStackTrace stackTrace = parseStacktrace(lines, sentryThread);
+    final List<SentryStackFrame> frames = stackTrace.getFrames();
+    if (frames == null || frames.isEmpty()) {
+      // skip threads without a stacktrace, they are not actionable
+      return null;
+    }
     sentryThread.setStacktrace(stackTrace);
     return sentryThread;
   }
@@ -238,6 +257,7 @@ private SentryStackTrace parseStacktrace(
     final Matcher waitingToLockRe = WAITING_TO_LOCK_RE.matcher("");
     final Matcher waitingToLockUnknownRe = WAITING_TO_LOCK_UNKNOWN_RE.matcher("");
     final Matcher blankRe = BLANK_RE.matcher("");
+    final Matcher sysTidRe = SYS_TID_RE.matcher("");
 
     while (lines.hasNext()) {
       final Line line = lines.next();
@@ -246,7 +266,12 @@ private SentryStackTrace parseStacktrace(
         break;
       }
       final String text = line.text;
-      if (matches(javaRe, text)) {
+      if (matches(sysTidRe, text)) {
+        final Long sysTid = getLong(sysTidRe, 1, null);
+        if (sysTid != null && sysTid.equals(processId)) {
+          thread.setMain(true);
+        }
+      } else if (matches(javaRe, text)) {
         final SentryStackFrame frame = new SentryStackFrame();
         final String packageName = javaRe.group(1);
         final String className = javaRe.group(2);
@@ -365,6 +390,24 @@ private SentryStackTrace parseStacktrace(
     return stackTrace;
   }
 
+  private void markThreads() {
+    for (final @NotNull SentryThread thread : threads) {
+      if (Boolean.TRUE.equals(thread.isMain())) {
+        // the OS may have renamed the main thread to the (truncated) process name; normalize it
+        // back to "main" so downstream consumers see a consistent name
+        thread.setName("main");
+
+        // since it's an ANR, the crashed thread will always be main
+        thread.setCrashed(true);
+        thread.setCurrent(!isBackground);
+      } else {
+        thread.setCrashed(false);
+        thread.setCurrent(false);
+        thread.setMain(false);
+      }
+    }
+  }
+
   private boolean matches(final @NotNull Matcher matcher, final @NotNull String text) {
     matcher.reset(text);
     return matcher.matches();
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt
index b7db35b63ce..ec5dbd58902 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt
@@ -100,12 +100,15 @@ class ThreadDumpParserTest {
     parser.parse(lines)
     val threads = parser.threads
     // just verifying a few important threads, as there are many
-    val thread = threads.find { it.name == "samples.android" }
+    // the OS named the main thread after the process; it is detected via sysTid==processId (9955)
+    // and its name is normalized back to "main"
+    val thread = threads.find { it.isMain == true }
     assertEquals(9955, thread!!.id)
+    assertEquals("main", thread.name)
     assertNull(thread.state)
-    assertEquals(false, thread.isCrashed)
-    assertEquals(false, thread.isMain)
-    assertEquals(false, thread.isCurrent)
+    assertEquals(true, thread.isCrashed)
+    assertEquals(true, thread.isMain)
+    assertEquals(true, thread.isCurrent)
 
     // Reverse frames so we can index them with the active frame at index 0
     val frames = thread.stacktrace!!.frames!!.reversed()
@@ -182,6 +185,38 @@ class ThreadDumpParserTest {
     assertEquals(8.054, artContext.gcWaitingTime)
   }
 
+  @Test
+  fun `detects main thread via sysTid matching the process id when OS renames it`() {
+    val lines = Lines.readLines(File("src/test/resources/thread_dump_process_name_main.txt"))
+    val parser =
+      ThreadDumpParser(SentryOptions().apply { addInAppInclude("io.sentry.samples") }, false)
+    parser.parse(lines)
+    val threads = parser.threads
+    // the main thread has been renamed to the (truncated) process name, but its sysTid equals the
+    // process id, which is how we detect it - its name is then normalized back to "main"
+    val main = threads.find { it.isMain == true }
+    assertNotNull(main)
+    assertEquals("main", main!!.name)
+    assertEquals(true, main.isCrashed)
+    assertEquals(true, main.isCurrent)
+    val background = threads.find { it.name == "Thread-2" }
+    assertNotNull(background)
+    assertEquals(false, background!!.isMain)
+    assertEquals(false, background.isCrashed)
+  }
+
+  @Test
+  fun `skips threads without a stacktrace`() {
+    val lines = Lines.readLines(File("src/test/resources/thread_dump_no_stacktrace.txt"))
+    val parser =
+      ThreadDumpParser(SentryOptions().apply { addInAppInclude("io.sentry.samples") }, false)
+    parser.parse(lines)
+    val threads = parser.threads
+    // the thread without any frames is skipped, only the one with a stacktrace remains
+    assertEquals(1, threads.size)
+    assertEquals("main", threads.first().name)
+  }
+
   @Test
   fun `thread dump garbage`() {
     val lines = Lines.readLines(File("src/test/resources/thread_dump_bad_data.txt"))
diff --git a/sentry-android-core/src/test/resources/thread_dump_no_stacktrace.txt b/sentry-android-core/src/test/resources/thread_dump_no_stacktrace.txt
new file mode 100644
index 00000000000..e0411327546
--- /dev/null
+++ b/sentry-android-core/src/test/resources/thread_dump_no_stacktrace.txt
@@ -0,0 +1,21 @@
+
+----- pid 12345 at 2024-01-01 10:00:00.000000000+0000 -----
+Cmd line: io.sentry.samples.android
+Build fingerprint: 'google/sdk_gphone64_arm64/emu64a:13/TE1A.220922.012/9302419:userdebug/dev-keys'
+ABI: 'arm64'
+
+DALVIK THREADS (2):
+"main" prio=5 tid=1 Runnable
+  | group="main" sCount=0 ucsCount=0 flags=0 obj=0x72a985e0 self=0xb400007cabc57380
+  | sysTid=12345 nice=-10 cgrp=top-app sched=0/0 handle=0x7deceb74f8
+  | state=R schedstat=( 324804784 183300334 997 ) utm=23 stm=8 core=3 HZ=100
+  | stack=0x7ff93a9000-0x7ff93ab000 stackSize=8188KB
+  | held mutexes=
+  at io.sentry.samples.android.MainActivity.onCreate(MainActivity.java:42)
+
+"Thread-2" prio=5 tid=2 Sleeping
+  | group="main" sCount=1 ucsCount=0 flags=1 obj=0x136c0518 self=0xb400007cabc82ad0
+  | sysTid=12346 nice=0 cgrp=top-app sched=0/0 handle=0x7ace0a9cb0
+  | state=S schedstat=( 574039 4838087 11 ) utm=0 stm=0 core=1 HZ=100
+  | stack=0x7acdfb2000-0x7acdfb4000 stackSize=991KB
+  | held mutexes=
diff --git a/sentry-android-core/src/test/resources/thread_dump_process_name_main.txt b/sentry-android-core/src/test/resources/thread_dump_process_name_main.txt
new file mode 100644
index 00000000000..80b864aae73
--- /dev/null
+++ b/sentry-android-core/src/test/resources/thread_dump_process_name_main.txt
@@ -0,0 +1,24 @@
+
+----- pid 12345 at 2024-01-01 10:00:00.000000000+0000 -----
+Cmd line: io.sentry.samples.android
+Build fingerprint: 'google/sdk_gphone64_arm64/emu64a:13/TE1A.220922.012/9302419:userdebug/dev-keys'
+ABI: 'arm64'
+
+DALVIK THREADS (2):
+"io.sentry.samples.android" prio=5 tid=1 Runnable
+  | group="main" sCount=0 ucsCount=0 flags=0 obj=0x72a985e0 self=0xb400007cabc57380
+  | sysTid=12345 nice=-10 cgrp=top-app sched=0/0 handle=0x7deceb74f8
+  | state=R schedstat=( 324804784 183300334 997 ) utm=23 stm=8 core=3 HZ=100
+  | stack=0x7ff93a9000-0x7ff93ab000 stackSize=8188KB
+  | held mutexes=
+  at io.sentry.samples.android.MainActivity.onCreate(MainActivity.java:42)
+
+"Thread-2" prio=5 tid=2 Sleeping
+  | group="main" sCount=1 ucsCount=0 flags=1 obj=0x136c0518 self=0xb400007cabc82ad0
+  | sysTid=12346 nice=0 cgrp=top-app sched=0/0 handle=0x7ace0a9cb0
+  | state=S schedstat=( 574039 4838087 11 ) utm=0 stm=0 core=1 HZ=100
+  | stack=0x7acdfb2000-0x7acdfb4000 stackSize=991KB
+  | held mutexes=
+  at java.lang.Thread.sleep(Native method)
+  at io.sentry.samples.android.BackgroundWorker.run(BackgroundWorker.java:20)
+

From a5db1a2886c386bbed4272e74192f95a1dc9e260 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 8 Jul 2026 14:03:56 +0200
Subject: [PATCH 281/391] fix(android): Avoid Math floor APIs (#5743)

* fix(android): Avoid Math floor APIs

Replace Math.floorDiv and Math.floorMod in the shared timestamp formatter with local helpers so Android consumers do not call APIs unavailable on older supported Android versions.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* fix(android): Add attributed floor math helpers

Move the floor division and modulo replacements into a dedicated SentryMath class with Android Open Source Project attribution and third-party notices. Add tests that compare the helper behavior against Java Math for edge cases.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(android): Use independent floor math helpers

Remove the incorrect AOSP attribution for SentryMath. The referenced Android Math source is GPLv2 with the Classpath exception, not Apache 2.0. Implement the helpers directly from quotient and remainder semantics instead.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(android): Adapt floor math from Guava

Use Apache-licensed Guava LongMath floor division logic for SentryMath and restore the matching third-party attribution. Keep floorMod implemented through floorDiv so it matches Math.floorMod for negative divisors too.

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* docs(changelog): Mention Android NoSuchMethodError

Update the unreleased changelog entry to call out the Android API compatibility failure more directly.

Co-Authored-By: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 THIRD_PARTY_NOTICES.md                        | 28 +++++++++
 .../io/sentry/vendor/SentryIso8601Utils.java  |  8 +--
 .../java/io/sentry/vendor/SentryMath.java     | 40 +++++++++++++
 .../java/io/sentry/vendor/SentryMathTest.kt   | 58 +++++++++++++++++++
 5 files changed, 131 insertions(+), 4 deletions(-)
 create mode 100644 sentry/src/main/java/io/sentry/vendor/SentryMath.java
 create mode 100644 sentry/src/test/java/io/sentry/vendor/SentryMathTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e05a7a1af38..9bca5afb254 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,7 @@
 
 ### Fixes
 
+- Fix `NoSuchMethodError` when using `Math.floorDiv`/`Math.floorMod` on Android < 24 ([#5743](https://github.com/getsentry/sentry-java/pull/5743))
 - Fix main thread identification parsing for ApplicationExitInfo ANRs ([#5733](https://github.com/getsentry/sentry-java/pull/5733))
 - Do not send threads without stacktraces for ApplicationExitInfo ANRs ([#5733](https://github.com/getsentry/sentry-java/pull/5733))
 - Record byte-level client reports when event processors discard logs or trace metrics ([#5718](https://github.com/getsentry/sentry-java/pull/5718))
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index 7b87b92dcb3..381c39cfd68 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -34,6 +34,34 @@ limitations under the License.
 
 ---
 
+## Google Guava — LongMath (Apache 2.0)
+
+**Source:** https://github.com/google/guava/blob/v33.0.0/guava/src/com/google/common/math/LongMath.java<br>
+**License:** Apache License 2.0<br>
+**Copyright:** Copyright (C) 2011 The Guava Authors
+
+### Scope
+
+The Sentry Java SDK includes adapted floor division logic from Guava's `LongMath` class to support older Android API levels. The code resides in `io.sentry.vendor.SentryMath`.
+
+```
+Copyright (C) 2011 The Guava Authors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+---
+
 ## FasterXML Jackson — ISO8601Utils (Apache 2.0)
 
 **Source:** https://github.com/FasterXML/jackson-databind<br>
diff --git a/sentry/src/main/java/io/sentry/vendor/SentryIso8601Utils.java b/sentry/src/main/java/io/sentry/vendor/SentryIso8601Utils.java
index b5cb1811aa9..134a13e72a5 100644
--- a/sentry/src/main/java/io/sentry/vendor/SentryIso8601Utils.java
+++ b/sentry/src/main/java/io/sentry/vendor/SentryIso8601Utils.java
@@ -142,8 +142,8 @@ public static long parseTimestamp(final @NotNull String timestamp) {
       return formatTimestampWithCalendar(millis);
     }
 
-    final long epochDay = Math.floorDiv(millis, MILLIS_PER_DAY);
-    int millisOfDay = (int) Math.floorMod(millis, MILLIS_PER_DAY);
+    final long epochDay = SentryMath.floorDiv(millis, MILLIS_PER_DAY);
+    int millisOfDay = (int) SentryMath.floorMod(millis, MILLIS_PER_DAY);
 
     final int[] yearMonthDay = epochDayToYearMonthDay(epochDay);
     final int hour = millisOfDay / (int) MILLIS_PER_HOUR;
@@ -281,7 +281,7 @@ private static long epochMillis(
 
   private static long daysFromYearMonthDay(int year, final int month, final int day) {
     year -= month <= 2 ? 1 : 0;
-    final long era = Math.floorDiv(year, 400);
+    final long era = SentryMath.floorDiv(year, 400L);
     final int yearOfEra = (int) (year - era * 400);
     final int dayOfYear = (153 * (month + (month > 2 ? -3 : 9)) + 2) / 5 + day - 1;
     final int dayOfEra = yearOfEra * 365 + yearOfEra / 4 - yearOfEra / 100 + dayOfYear;
@@ -290,7 +290,7 @@ private static long daysFromYearMonthDay(int year, final int month, final int da
 
   private static int[] epochDayToYearMonthDay(long epochDay) {
     epochDay += DAYS_0000_TO_1970;
-    final long era = Math.floorDiv(epochDay, 146097);
+    final long era = SentryMath.floorDiv(epochDay, 146097L);
     final int dayOfEra = (int) (epochDay - era * 146097);
     final int yearOfEra = (dayOfEra - dayOfEra / 1460 + dayOfEra / 36524 - dayOfEra / 146096) / 365;
     final int year = (int) (yearOfEra + era * 400);
diff --git a/sentry/src/main/java/io/sentry/vendor/SentryMath.java b/sentry/src/main/java/io/sentry/vendor/SentryMath.java
new file mode 100644
index 00000000000..50a8118d462
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/vendor/SentryMath.java
@@ -0,0 +1,40 @@
+/*
+ * Adapted from https://github.com/google/guava/blob/v33.0.0/guava/src/com/google/common/math/LongMath.java
+ *
+ * Copyright (C) 2011 The Guava Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.sentry.vendor;
+
+final class SentryMath {
+
+  private SentryMath() {}
+
+  static long floorDiv(final long x, final long y) {
+    final long quotient = x / y;
+    final long remainder = x - y * quotient;
+
+    if (remainder == 0) {
+      return quotient;
+    }
+
+    final int signum = 1 | (int) ((x ^ y) >> (Long.SIZE - 1));
+    return signum < 0 ? quotient + signum : quotient;
+  }
+
+  static long floorMod(final long x, final long y) {
+    return x - floorDiv(x, y) * y;
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/vendor/SentryMathTest.kt b/sentry/src/test/java/io/sentry/vendor/SentryMathTest.kt
new file mode 100644
index 00000000000..32b9f8621d0
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/vendor/SentryMathTest.kt
@@ -0,0 +1,58 @@
+package io.sentry.vendor
+
+import com.google.common.truth.Truth.assertThat
+import kotlin.test.Test
+import kotlin.test.assertFailsWith
+
+class SentryMathTest {
+  @Test
+  fun `floorDiv matches Java Math floorDiv`() {
+    values.forEach { x ->
+      divisors.forEach { y -> assertThat(SentryMath.floorDiv(x, y)).isEqualTo(Math.floorDiv(x, y)) }
+    }
+  }
+
+  @Test
+  fun `floorMod matches Java Math floorMod`() {
+    values.forEach { x ->
+      divisors.forEach { y -> assertThat(SentryMath.floorMod(x, y)).isEqualTo(Math.floorMod(x, y)) }
+    }
+  }
+
+  @Test
+  fun `floorDiv throws when dividing by zero`() {
+    assertFailsWith<ArithmeticException> { SentryMath.floorDiv(1L, 0L) }
+  }
+
+  @Test
+  fun `floorMod throws when dividing by zero`() {
+    assertFailsWith<ArithmeticException> { SentryMath.floorMod(1L, 0L) }
+  }
+
+  private companion object {
+    val values =
+      listOf(
+        Long.MIN_VALUE,
+        -86_400_001L,
+        -86_400_000L,
+        -86_399_999L,
+        -401L,
+        -400L,
+        -399L,
+        -2L,
+        -1L,
+        0L,
+        1L,
+        2L,
+        399L,
+        400L,
+        401L,
+        86_399_999L,
+        86_400_000L,
+        86_400_001L,
+        Long.MAX_VALUE,
+      )
+
+    val divisors = listOf(Long.MIN_VALUE, -146_097L, -400L, -1L, 1L, 400L, 146_097L, Long.MAX_VALUE)
+  }
+}

From 15e0febed59f66d2024c2ba6ce87527333219609 Mon Sep 17 00:00:00 2001
From: adinauer <2542832+adinauer@users.noreply.github.com>
Date: Wed, 8 Jul 2026 12:05:51 +0000
Subject: [PATCH 282/391] release: 8.48.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9bca5afb254..a396fed4583 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.48.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 4c0a1cffd1e..91122c1141f 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.47.0
+versionName=8.48.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 89c9fe1dc3afee6ee5c6a96342c62d052a6dcefe Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 8 Jul 2026 17:04:52 +0200
Subject: [PATCH 283/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.15.3 (#5728)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 8 ++++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a396fed4583..30fe301a349 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+### Dependencies
+
+- Bump Native SDK from v0.15.2 to v0.15.3 ([#5728](https://github.com/getsentry/sentry-java/pull/5728))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0153)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.15.2...0.15.3)
+
 ## 8.48.0
 
 ### Features
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 1a145040e7c..e153eb8bc4a 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -166,7 +166,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.2" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.3" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From d12e9b589d76fe3844d17c176b06126417792528 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 9 Jul 2026 07:11:40 +0000
Subject: [PATCH 284/391] chore(deps): bump the github-actions group with 2
 updates (#5749)

Bumps the github-actions group with 2 updates: [github/codeql-action/init](https://github.com/github/codeql-action) and [github/codeql-action/analyze](https://github.com/github/codeql-action).


Updates `github/codeql-action/init` from 4.36.3 to 4.37.0
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/54f647b7e1bb85c95cddabcd46b0c578ec92bc1a...99df26d4f13ea111d4ec1a7dddef6063f76b97e9)

Updates `github/codeql-action/analyze` from 4.36.3 to 4.37.0
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/54f647b7e1bb85c95cddabcd46b0c578ec92bc1a...99df26d4f13ea111d4ec1a7dddef6063f76b97e9)

---
updated-dependencies:
- dependency-name: github/codeql-action/init
  dependency-version: 4.37.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.37.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql-analysis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 274232c8131..0c4fda8cfd3 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # pin@v2
+        uses: github/codeql-action/init@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # pin@v2
+        uses: github/codeql-action/analyze@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # pin@v2

From d99fe3360932e9cb92c32a4e23653240eceb8a96 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Thu, 9 Jul 2026 09:28:59 +0200
Subject: [PATCH 285/391] fix(anr): Detect main thread from tombstone via pid
 matching thread id (#5742)

* fix(anr): Detect main thread from tombstone via pid matching thread id

On Linux/Android the main thread's kernel thread id always equals the process
id, so match a tombstone thread whose id equals the pid as the main thread and
normalize its name back to "main". This is more robust than relying on the
OS-assigned thread name, which some versions/OEMs replace with the process name.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* Clarify main thread detection comments

* Fix typo in main thread detection comment

* Remove redundant comments in tombstone parser test

* Fix failing tests

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  4 ++
 .../internal/tombstone/TombstoneParser.java   |  9 +++
 .../android/core/TombstoneIntegrationTest.kt  |  3 +-
 .../internal/tombstone/TombstoneParserTest.kt | 72 +++++++++++++++++++
 4 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 30fe301a349..6a83f72f168 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+
+- Fix main thread identification for tombstone (native crash) events ([#5742](https://github.com/getsentry/sentry-java/pull/5742))
+
 ### Dependencies
 
 - Bump Native SDK from v0.15.2 to v0.15.3 ([#5728](https://github.com/getsentry/sentry-java/pull/5728))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java
index 1f142b52c9a..c3966615899 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/tombstone/TombstoneParser.java
@@ -114,6 +114,15 @@ private List<SentryThread> createThreads(
         // the backend currently requires a stack-trace in exception
         exc.setStacktrace(stacktrace);
       }
+
+      // thread id always equals the process id,
+      // so we use it to reliably detect the main thread
+      if (tombstone.pid == threadEntryValue.id) {
+        // the OS may provide a (truncated) process name; normalize it
+        // back to "main" so downstream consumers see a consistent name
+        thread.setName("main");
+        thread.setMain(true);
+      }
       threads.add(thread);
     }
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/TombstoneIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/TombstoneIntegrationTest.kt
index 9890d553dbc..e3e88d04f7a 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/TombstoneIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/TombstoneIntegrationTest.kt
@@ -75,7 +75,8 @@ class TombstoneIntegrationTest : ApplicationExitIntegrationTestBase<TombstoneHin
     val crashedThreadId = 21891L
     assertEquals(crashedThreadId, event.exceptions!![0].threadId)
     val crashedThread = event.threads!!.find { thread -> thread.id == crashedThreadId }
-    assertEquals("samples.android", crashedThread!!.name)
+    assertEquals("main", crashedThread!!.name)
+    assertTrue(crashedThread.isMain!!)
     assertTrue(crashedThread.isCrashed!!)
 
     // Verify that frames from the app's native library are marked as in-app
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt
index 34e704188c4..70fc48fd9be 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/tombstone/TombstoneParserTest.kt
@@ -12,6 +12,7 @@ import java.io.StringWriter
 import java.util.zip.GZIPInputStream
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertNotEquals
 import kotlin.test.assertNotNull
 import org.mockito.kotlin.mock
 
@@ -99,6 +100,10 @@ class TombstoneParserTest {
 
     // threads
     assertEquals(62, event.threads!!.size)
+    val mainThread = event.threads!!.single { it.isMain == true }
+    assertEquals(21891, mainThread.id)
+    assertEquals("main", mainThread.name)
+
     for (thread in event.threads!!) {
       assertNotNull(thread.id)
       if (thread.id == crashedThreadId) {
@@ -397,6 +402,73 @@ class TombstoneParserTest {
     assertEquals(expectedJson, actualJson)
   }
 
+  @Test
+  fun `identifies the main thread via pid matching the thread id and normalizes its name`() {
+    val tombstone =
+      Tombstone.Builder()
+        .pid(1000)
+        .tid(2000)
+        .signal(Signal(11, "SIGSEGV", 1, "SEGV_MAPERR", false, 0, 0, false, 0, null))
+        // main thread: id == pid, but the OS renamed it to the process name
+        .addThread(
+          TombstoneThread(
+            1000,
+            "io.sentry.samples.android",
+            emptyList(),
+            emptyList(),
+            emptyList(),
+            listOf(BacktraceFrame(0, 0x100, 0, "main", 0, "/system/lib64/libc.so", 0, "")),
+            emptyList(),
+            0,
+            0,
+          )
+        )
+        .addThread(
+          TombstoneThread(
+            2000,
+            "crashed-worker",
+            emptyList(),
+            emptyList(),
+            emptyList(),
+            listOf(BacktraceFrame(0, 0x200, 0, "crash", 0, "/system/lib64/libc.so", 0, "")),
+            emptyList(),
+            0,
+            0,
+          )
+        )
+        .addThread(
+          TombstoneThread(
+            3000,
+            "Thread-3",
+            emptyList(),
+            emptyList(),
+            emptyList(),
+            listOf(BacktraceFrame(0, 0x300, 0, "work", 0, "/system/lib64/libc.so", 0, "")),
+            emptyList(),
+            0,
+            0,
+          )
+        )
+        .build()
+
+    val event = parser.parse(tombstone)
+    val threads = event.threads!!
+
+    val main = threads.single { it.isMain == true }
+    assertEquals(1000, main.id)
+    assertEquals("main", main.name)
+
+    val crashed = threads.single { it.isCrashed == true }
+    assertEquals(2000, crashed.id)
+    assertNotEquals(true, crashed.isMain)
+    assertEquals("crashed-worker", crashed.name)
+
+    val background = threads.single { it.id == 3000L }
+    assertNotEquals(true, background.isMain)
+    assertNotEquals(true, background.isCrashed)
+    assertEquals("Thread-3", background.name)
+  }
+
   @Test
   fun `parses tombstone when nativeLibraryDir is null`() {
     val tombstoneStream =

From 913e479bed3732dc3c554ecb911be3097db42ed5 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Thu, 9 Jul 2026 09:56:06 +0200
Subject: [PATCH 286/391] Fix Math.floorDiv/floorMod changelog entry to say
 Java 8 (#5748)

It said Android < API Level 24 before but it's Java 8 that's affected because the specific overloads that were used aren't available there.
---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6a83f72f168..f3e2fd47900 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -34,7 +34,7 @@
 
 ### Fixes
 
-- Fix `NoSuchMethodError` when using `Math.floorDiv`/`Math.floorMod` on Android < 24 ([#5743](https://github.com/getsentry/sentry-java/pull/5743))
+- Fix `NoSuchMethodError` from using `Math.floorDiv`/`Math.floorMod` overloads that are unavailable on Java 8 ([#5743](https://github.com/getsentry/sentry-java/pull/5743))
 - Fix main thread identification parsing for ApplicationExitInfo ANRs ([#5733](https://github.com/getsentry/sentry-java/pull/5733))
 - Do not send threads without stacktraces for ApplicationExitInfo ANRs ([#5733](https://github.com/getsentry/sentry-java/pull/5733))
 - Record byte-level client reports when event processors discard logs or trace metrics ([#5718](https://github.com/getsentry/sentry-java/pull/5718))

From 3199ff8543927648e3a69d3e37ae36aec62b5565 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Thu, 9 Jul 2026 11:02:19 +0200
Subject: [PATCH 287/391] feat(otel): Add OpenTelemetry compatibility BOM
 (#5629)

* feat(otel): Add OpenTelemetry compatibility BOM

Add an opt-in Sentry OpenTelemetry BOM that imports the tested OpenTelemetry stable and alpha BOMs and constrains Sentry OpenTelemetry modules to the SDK version.

Keep the main Sentry BOM from managing the dedicated OpenTelemetry BOM so regular Sentry consumers are unaffected.

* changelog

* build(otel): Declare BOM constraints explicitly

Replace dynamic publication scanning with explicit Sentry OpenTelemetry project constraints.

This avoids cross-project evaluation while preserving the generated BOM dependency management.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs(otel): Document native Gradle BOM usage

Add a platform example for Gradle users that do not use the Spring dependency management plugin.

Clarify when to use enforcedPlatform if another platform also manages OpenTelemetry versions.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs(changelog): Add OpenTelemetry BOM usage snippets

Document the common Spring Boot Gradle plugin setup first, then native Gradle and Maven usage.

This gives release note readers enough guidance to import the new BOM without opening the module README.

Co-Authored-By: Claude <noreply@anthropic.com>

* ci(otel): Defer registry entry for OpenTelemetry BOM

Comment out the new OpenTelemetry BOM registry entry until the artifact has been released once.

This keeps craft from looking up an SDK package that is not available yet.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs(changelog): Move OpenTelemetry BOM entry to Unreleased

The entry landed in the 8.48.0 section after merging main because
that release was cut while this branch was in flight. Move it back
to Unreleased where it belongs.

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .craft.yml                                    |  2 +
 CHANGELOG.md                                  | 26 ++++++
 README.md                                     |  1 +
 gradle/libs.versions.toml                     |  5 ++
 sentry-bom/build.gradle.kts                   |  1 +
 .../sentry-opentelemetry-bom/README.md        | 84 +++++++++++++++++++
 .../sentry-opentelemetry-bom/build.gradle.kts | 24 ++++++
 settings.gradle.kts                           |  1 +
 8 files changed, 144 insertions(+)
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-bom/README.md
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-bom/build.gradle.kts

diff --git a/.craft.yml b/.craft.yml
index cc4636cd32d..bee668917c1 100644
--- a/.craft.yml
+++ b/.craft.yml
@@ -45,6 +45,8 @@ targets:
       maven:io.sentry:sentry-launchdarkly-android:
       maven:io.sentry:sentry-launchdarkly-server:
       maven:io.sentry:sentry-opentelemetry-agent:
+      # TODO: Add after first release of the artifact.
+      # maven:io.sentry:sentry-opentelemetry-bom:
       maven:io.sentry:sentry-opentelemetry-agentcustomization:
       maven:io.sentry:sentry-opentelemetry-agentless:
       maven:io.sentry:sentry-opentelemetry-agentless-spring:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f3e2fd47900..95b21f4380a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,32 @@
 
 ## Unreleased
 
+### Features
+
+- Add `io.sentry:sentry-opentelemetry-bom` to align Sentry OpenTelemetry modules with tested OpenTelemetry dependencies ([#5629](https://github.com/getsentry/sentry-java/pull/5629))
+  - Spring Boot Gradle plugin: add the Sentry BOM to `dependencyManagement`; explicit imports are applied after Spring Boot's implicit BOM
+    ```kotlin
+    dependencyManagement {
+      imports {
+        mavenBom("io.sentry:sentry-opentelemetry-bom:<sentry-version>")
+      }
+    }
+    ```
+  - Gradle: import it as a platform and omit versions from Sentry OpenTelemetry and OpenTelemetry dependencies
+    ```kotlin
+    implementation(platform("io.sentry:sentry-opentelemetry-bom:<sentry-version>"))
+    ```
+  - Maven: import it before Spring Boot's BOM in the same `<dependencyManagement>` block, or in the child POM when using `spring-boot-starter-parent`
+    ```xml
+    <dependency>
+      <groupId>io.sentry</groupId>
+      <artifactId>sentry-opentelemetry-bom</artifactId>
+      <version>${sentry.version}</version>
+      <type>pom</type>
+      <scope>import</scope>
+    </dependency>
+    ```
+
 ### Fixes
 
 - Fix main thread identification for tombstone (native crash) events ([#5742](https://github.com/getsentry/sentry-java/pull/5742))
diff --git a/README.md b/README.md
index 0aab8a4e75d..849aaf74457 100644
--- a/README.md
+++ b/README.md
@@ -64,6 +64,7 @@ Sentry SDK for Java and Android
 | sentry-launchdarkly-android             | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-launchdarkly-android?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-launchdarkly-android)             |
 | sentry-launchdarkly-server              | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-launchdarkly-server?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-launchdarkly-server)              |
 | sentry-opentelemetry-agent              | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-agent?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-agent)              |
+| sentry-opentelemetry-bom                | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-bom?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-bom)                |
 | sentry-opentelemetry-agentcustomization | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-agentcustomization?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-agentcustomization) |
 | sentry-opentelemetry-core               | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-core?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-core)               |
 | sentry-opentelemetry-otlp               | [![Maven Central Version](https://img.shields.io/maven-central/v/io.sentry/sentry-opentelemetry-otlp?style=for-the-badge&logo=sentry&color=green)](https://central.sonatype.com/artifact/io.sentry/sentry-opentelemetry-otlp)               |
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index e153eb8bc4a..fc102b6f5fb 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -26,6 +26,8 @@ nopen = "1.0.1"
 okhttp = "4.9.2"
 openfeature = "1.18.2"
 otel = "1.60.1"
+# Keep alpha OpenTelemetry BOMs in sync with their stable counterparts: <stable-version>-alpha.
+otelAlpha = "1.60.1-alpha"
 otelInstrumentation = "2.26.0"
 otelInstrumentationAlpha = "2.26.0-alpha"
 # check https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/dependencyManagement/build.gradle.kts#L49 for release version above to find a compatible version
@@ -153,7 +155,10 @@ otel-exporter-otlp = { module = "io.opentelemetry:opentelemetry-exporter-otlp",
 otel-exporter-logging = { module = "io.opentelemetry:opentelemetry-exporter-logging", version.ref = "otel" }
 otel-extension-autoconfigure = { module = "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure", version.ref = "otel" }
 otel-extension-autoconfigure-spi = { module = "io.opentelemetry:opentelemetry-sdk-extension-autoconfigure-spi", version.ref = "otel" }
+otel-bom = { module = "io.opentelemetry:opentelemetry-bom", version.ref = "otel" }
+otel-alpha-bom = { module = "io.opentelemetry:opentelemetry-bom-alpha", version.ref = "otelAlpha" }
 otel-instrumentation-bom = { module = "io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom", version.ref = "otelInstrumentation" }
+otel-instrumentation-alpha-bom = { module = "io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom-alpha", version.ref = "otelInstrumentationAlpha" }
 otel-javaagent = { module = "io.opentelemetry.javaagent:opentelemetry-javaagent", version.ref = "otelInstrumentation" }
 otel-javaagent-tooling = { module = "io.opentelemetry.javaagent:opentelemetry-javaagent-tooling", version.ref = "otelInstrumentationAlpha" }
 otel-javaagent-extension-api = { module = "io.opentelemetry.javaagent:opentelemetry-javaagent-extension-api", version.ref = "otelInstrumentationAlpha" }
diff --git a/sentry-bom/build.gradle.kts b/sentry-bom/build.gradle.kts
index 45ef7363d47..f219c964e52 100644
--- a/sentry-bom/build.gradle.kts
+++ b/sentry-bom/build.gradle.kts
@@ -9,6 +9,7 @@ dependencies {
       .filter {
         !it.name.startsWith("sentry-samples") &&
           it.name != project.name &&
+          !it.name.endsWith("-bom") &&
           !it.name.contains("test", ignoreCase = true) &&
           !it.name.contains("sentry-android-distribution")
       }
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bom/README.md b/sentry-opentelemetry/sentry-opentelemetry-bom/README.md
new file mode 100644
index 00000000000..c7522772d21
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-bom/README.md
@@ -0,0 +1,84 @@
+# sentry-opentelemetry-bom
+
+This BOM aligns Sentry OpenTelemetry modules with the OpenTelemetry artifacts tested by Sentry.
+
+Use this BOM only when you want Sentry to manage OpenTelemetry dependency versions for Sentry's OpenTelemetry integrations. Do not import it for regular Sentry usage unless you also want this OpenTelemetry version alignment.
+
+The BOM intentionally manages stable and `-alpha` OpenTelemetry artifacts, including incubator artifacts used by the OpenTelemetry instrumentation stack. It makes Sentry's tested OpenTelemetry versions authoritative, so verify dependency resolution before importing it if your application already uses newer OpenTelemetry versions.
+
+This BOM is primarily for classpath-based OpenTelemetry integrations such as `sentry-opentelemetry-agentless`, `sentry-opentelemetry-agentless-spring`, `sentry-opentelemetry-otlp`, and `sentry-opentelemetry-otlp-spring`. It does not change the OpenTelemetry dependencies shaded into the `sentry-opentelemetry-agent` Java agent JAR.
+
+## Dependency management ordering
+
+Ordering matters when another BOM, such as Spring Boot's dependency management, also manages OpenTelemetry versions.
+
+### Gradle
+
+With Gradle's native dependency management, import the BOM as a platform and omit versions from Sentry OpenTelemetry and OpenTelemetry dependencies:
+
+```kotlin
+dependencies {
+  implementation(platform("io.sentry:sentry-opentelemetry-bom:<sentry-version>"))
+
+  implementation("io.sentry:sentry-opentelemetry-agentless")
+  implementation("io.opentelemetry:opentelemetry-sdk-extension-autoconfigure")
+}
+```
+
+If another imported platform also manages OpenTelemetry versions, Gradle's normal version conflict resolution applies. Use `enforcedPlatform(...)` only when you need Sentry's tested OpenTelemetry versions to override other platforms.
+
+When using Gradle with the Spring dependency management plugin, the last imported BOM wins. Import this BOM after Spring Boot's dependency management so its OpenTelemetry versions take precedence:
+
+```kotlin
+dependencyManagement {
+  imports {
+    mavenBom("org.springframework.boot:spring-boot-dependencies:<spring-boot-version>")
+    mavenBom("io.sentry:sentry-opentelemetry-bom:<sentry-version>")
+  }
+}
+```
+
+If the Spring Boot Gradle plugin imports Spring Boot dependency management implicitly, add the Sentry BOM in your `dependencyManagement` block; explicit imports are applied after the implicit Spring Boot import.
+
+### Maven
+
+Maven uses different precedence rules: when multiple BOMs are imported in the same `<dependencyManagement>` block, the first declaration wins.
+
+When using `spring-boot-starter-parent`, declare `sentry-opentelemetry-bom` in the child POM's `<dependencyManagement>` block. Dependency management in the child POM takes precedence over the parent:
+
+```xml
+<dependencyManagement>
+  <dependencies>
+    <dependency>
+      <groupId>io.sentry</groupId>
+      <artifactId>sentry-opentelemetry-bom</artifactId>
+      <version>${sentry.version}</version>
+      <type>pom</type>
+      <scope>import</scope>
+    </dependency>
+  </dependencies>
+</dependencyManagement>
+```
+
+When importing `spring-boot-dependencies` manually in the same POM, import `sentry-opentelemetry-bom` first so Sentry's OpenTelemetry versions win:
+
+```xml
+<dependencyManagement>
+  <dependencies>
+    <dependency>
+      <groupId>io.sentry</groupId>
+      <artifactId>sentry-opentelemetry-bom</artifactId>
+      <version>${sentry.version}</version>
+      <type>pom</type>
+      <scope>import</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.springframework.boot</groupId>
+      <artifactId>spring-boot-dependencies</artifactId>
+      <version>${spring-boot.version}</version>
+      <type>pom</type>
+      <scope>import</scope>
+    </dependency>
+  </dependencies>
+</dependencyManagement>
+```
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bom/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-bom/build.gradle.kts
new file mode 100644
index 00000000000..d945002b716
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-bom/build.gradle.kts
@@ -0,0 +1,24 @@
+plugins {
+  `java-platform`
+  `maven-publish`
+}
+
+javaPlatform.allowDependencies()
+
+dependencies {
+  api(platform(libs.otel.bom))
+  api(platform(libs.otel.alpha.bom))
+  api(platform(libs.otel.instrumentation.bom))
+  api(platform(libs.otel.instrumentation.alpha.bom))
+
+  constraints {
+    api(projects.sentryOpentelemetry.sentryOpentelemetryAgent)
+    api(projects.sentryOpentelemetry.sentryOpentelemetryAgentcustomization)
+    api(projects.sentryOpentelemetry.sentryOpentelemetryAgentless)
+    api(projects.sentryOpentelemetry.sentryOpentelemetryAgentlessSpring)
+    api(projects.sentryOpentelemetry.sentryOpentelemetryBootstrap)
+    api(projects.sentryOpentelemetry.sentryOpentelemetryCore)
+    api(projects.sentryOpentelemetry.sentryOpentelemetryOtlp)
+    api(projects.sentryOpentelemetry.sentryOpentelemetryOtlpSpring)
+  }
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 2b3401d77ca..7fb5c627912 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -84,6 +84,7 @@ include(
     "sentry-opentelemetry:sentry-opentelemetry-core",
     "sentry-opentelemetry:sentry-opentelemetry-agentcustomization",
     "sentry-opentelemetry:sentry-opentelemetry-agent",
+    "sentry-opentelemetry:sentry-opentelemetry-bom",
     "sentry-opentelemetry:sentry-opentelemetry-agentless",
     "sentry-opentelemetry:sentry-opentelemetry-agentless-spring",
     "sentry-opentelemetry:sentry-opentelemetry-otlp",

From a979f23ef2a2e67841b020b77d136f4d5eae3f58 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Thu, 9 Jul 2026 16:16:41 +0200
Subject: [PATCH 288/391] fix(spring): Support Spring Boot 4.1 (#5573)

* fix(spring): Support Spring Boot 4.1

Bump OpenTelemetry and Spring Boot dependencies to compatible versions so the Spring Boot 4 OpenTelemetry sample works with Spring Boot 4.1.

Keep the Spring 7 sample on the repository Kotlin compiler version when importing the Spring Boot BOM, and add Spring Boot 4.1 to the system test matrix.

Fixes GH-5561

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* build: Bump Kotlin to 2.3.21

Align the global Kotlin version with Spring Boot 4.1 and remove the now-unneeded Spring 7 BOM override.

Also remove unused Spring 7-specific Kotlin aliases from the version catalog.

Co-Authored-By: Claude <noreply@anthropic.com>

* docs(changelog): Move bump entry to Unreleased and add version details

Move the Spring Boot 4 / OpenTelemetry dependency bump entry from
8.44.1 to the Unreleased section and add sub-list items showing
each dependency version change.

Co-Authored-By: Claude <noreply@anthropic.com>

* fix(spring): Fix Spring 7 sample test compilation in SB4 matrix

The Spring 7 sample had two dependency issues causing
compileTestKotlin to fail in the Spring Boot 4.x CI matrix:

1. Used libs.springboot.starter.test (Spring Boot 2.7.18) instead of
   libs.springboot4.starter.test, mixing Spring Framework 5.x test
   utilities with a Spring Framework 7.x runtime.

2. Missing Kotlin BOM import in dependencyManagement. Without it,
   Spring Boot 4.0.0's BOM downgraded kotlin-stdlib to 2.2.21 while
   the compiler and build tools remained at 2.3.21, causing
   ClasspathEntrySnapshotTransform initialization failures.

Co-Authored-By: Claude <noreply@anthropic.com>

* mention BOM in changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 .github/workflows/spring-boot-4-matrix.yml    |  2 +-
 CHANGELOG.md                                  |  8 +++++++
 gradle/libs.versions.toml                     | 23 ++++++++-----------
 .../sentry-samples-spring-7/build.gradle.kts  |  9 ++++++--
 4 files changed, 25 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index a1da787305c..cf30cf0500f 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -21,7 +21,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        springboot-version: [ '4.0.0', '4.0.5' ]
+        springboot-version: [ '4.0.0', '4.0.5', '4.1.0' ]
 
     name: Spring Boot ${{ matrix.springboot-version }}
     env:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 95b21f4380a..18713588b48 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -34,6 +34,14 @@
 
 ### Dependencies
 
+- Bump OpenTelemetry to support Spring Boot 4.1 ([#5573](https://github.com/getsentry/sentry-java/pull/5573))
+  - If this causes issues for you because you are also using Spring Boot Dependency Management Plugin (io.spring.dependency-management),
+    which may downgrade the OpenTelemetry SDK, please have a look at the changelog entry above that explains how to use `sentry-opentelemetry-bom`.
+  - OpenTelemetry to 1.63.0 (was 1.60.1)
+  - OpenTelemetry Instrumentation to 2.29.0 (was 2.26.0)
+  - OpenTelemetry Instrumentation Alpha to 2.29.0-alpha (was 2.26.0-alpha)
+  - OpenTelemetry Semantic Conventions to 1.42.0 (was 1.40.0)
+  - OpenTelemetry Semantic Conventions Alpha to 1.42.0-alpha (was 1.40.0-alpha)
 - Bump Native SDK from v0.15.2 to v0.15.3 ([#5728](https://github.com/getsentry/sentry-java/pull/5728))
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0153)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.15.2...0.15.3)
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index fc102b6f5fb..3a409707f3f 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -13,8 +13,7 @@ feign = "11.6"
 gummyBears = "0.12.0"
 jackson = "2.18.3"
 jetbrainsCompose = "1.6.11"
-kotlin = "2.2.0"
-kotlinSpring7 = "2.2.0"
+kotlin = "2.3.21"
 kotlin-compatible-version = "1.9"
 ksp = "2.3.9"
 ktorClient = "3.0.0"
@@ -25,14 +24,13 @@ nopen = "1.0.1"
 # see https://developer.android.com/jetpack/androidx/releases/compose-kotlin
 okhttp = "4.9.2"
 openfeature = "1.18.2"
-otel = "1.60.1"
-# Keep alpha OpenTelemetry BOMs in sync with their stable counterparts: <stable-version>-alpha.
-otelAlpha = "1.60.1-alpha"
-otelInstrumentation = "2.26.0"
-otelInstrumentationAlpha = "2.26.0-alpha"
+otel = "1.63.0"
+otelAlpha = "1.63.0-alpha"
+otelInstrumentation = "2.29.0"
+otelInstrumentationAlpha = "2.29.0-alpha"
 # check https://github.com/open-telemetry/opentelemetry-java-instrumentation/blob/main/dependencyManagement/build.gradle.kts#L49 for release version above to find a compatible version
-otelSemanticConventions = "1.40.0"
-otelSemanticConventionsAlpha = "1.40.0-alpha"
+otelSemanticConventions = "1.42.0"
+otelSemanticConventionsAlpha = "1.42.0-alpha"
 retrofit = "2.9.0"
 room2 = "2.8.4"
 room3 = "3.0.0-rc01"
@@ -40,10 +38,10 @@ sagp = "6.13.0"
 sqlite = "2.6.2"
 sqliteRc = "2.7.0-rc01" # Required by Room3 3.0.0-rc*
 slf4j = "1.7.30"
-spotless = "8.4.0"
+spotless = "8.6.0"
 springboot2 = "2.7.18"
 springboot3 = "3.5.0"
-springboot4 = "4.0.0"
+springboot4 = "4.1.0"
 sqldelight = "2.3.2"
 
 # Android
@@ -54,8 +52,6 @@ minSdk = "21"
 [plugins]
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 kotlin-spring = { id = "org.jetbrains.kotlin.plugin.spring", version.ref = "kotlin" }
-kotlin-spring7 = { id = "org.jetbrains.kotlin.plugin.spring", version.ref = "kotlinSpring7" }
-kotlin-jvm-spring7 = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlinSpring7" }
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
 kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
@@ -132,7 +128,6 @@ jackson-kotlin = { module = "com.fasterxml.jackson.module:jackson-module-kotlin"
 jetbrains-annotations = { module = "org.jetbrains:annotations", version = "23.0.0" }
 kotlin-bom = { module = "org.jetbrains.kotlin:kotlin-bom", version.ref = "kotlin" }
 kotlin-test-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kotlin" }
-kotlin-test-junit-spring7 = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kotlinSpring7" }
 kotlinx-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
 kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "coroutines" }
 ktor-client-core = { module = "io.ktor:ktor-client-core", version.ref = "ktorClient" }
diff --git a/sentry-samples/sentry-samples-spring-7/build.gradle.kts b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
index daeab91f28d..b0cd329777d 100644
--- a/sentry-samples/sentry-samples-spring-7/build.gradle.kts
+++ b/sentry-samples/sentry-samples-spring-7/build.gradle.kts
@@ -26,7 +26,12 @@ java.sourceCompatibility = JavaVersion.VERSION_17
 
 java.targetCompatibility = JavaVersion.VERSION_17
 
-dependencyManagement { imports { mavenBom(SpringBootPlugin.BOM_COORDINATES) } }
+dependencyManagement {
+  imports {
+    mavenBom(SpringBootPlugin.BOM_COORDINATES)
+    mavenBom(libs.kotlin.bom.get().toString())
+  }
+}
 
 dependencies {
   implementation(Config.Libs.springWeb)
@@ -49,7 +54,7 @@ dependencies {
 
   testImplementation(projects.sentrySystemTestSupport)
   testImplementation(libs.kotlin.test.junit)
-  testImplementation(libs.springboot.starter.test) {
+  testImplementation(libs.springboot4.starter.test) {
     exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
   }
 }

From 20be537e26bae44a7ffdb1b207ea3f631a711a15 Mon Sep 17 00:00:00 2001
From: Stefan Jandl <reg@bitfox.at>
Date: Fri, 10 Jul 2026 13:41:16 +0200
Subject: [PATCH 289/391] feat(android): forward app hang options to NDK
 (#5623)

---
 CHANGELOG.md                                  |  9 +++
 .../api/sentry-android-core.api               |  4 ++
 .../android/core/ManifestMetadataReader.java  | 19 ++++++
 .../android/core/SentryAndroidOptions.java    | 60 +++++++++++++++++++
 .../core/ManifestMetadataReaderTest.kt        | 50 ++++++++++++++++
 .../android/core/SentryAndroidOptionsTest.kt  |  7 +++
 .../java/io/sentry/android/ndk/SentryNdk.java |  3 +
 .../io/sentry/android/ndk/SentryNdkTest.kt    | 28 +++++++++
 .../src/main/java/io/sentry/SentryClient.java | 10 ++--
 .../test/java/io/sentry/SentryClientTest.kt   | 46 ++++++++++++++
 10 files changed, 232 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 18713588b48..a3baff8d6b2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -64,6 +64,9 @@
   Sentry.finishExtendedAppStart()
   ```
 - Add `trace_metric_byte` data category and record byte-level client reports when trace metrics are discarded ([#5626](https://github.com/getsentry/sentry-java/pull/5626))
+- Expose sentry-native's heartbeat-based app-hang detection through `SentryAndroidOptions` ([#5623](https://github.com/getsentry/sentry-java/pull/5623))
+  - Enable via `setEnableNdkAppHangTracking(true)` (disabled by default) and tune the timeout with `setNdkAppHangTimeoutIntervalMillis(...)` (default `5000` ms), or the `io.sentry.ndk.app-hang.enable` / `io.sentry.ndk.app-hang.timeout-interval-millis` manifest entries
+  - Intended for hybrid SDKs: emit the heartbeat by calling the native `sentry_app_hang_heartbeat()` from the thread you want monitored. Independent of the JVM-based ANR detection (`setAnrEnabled`)
 - Support the `io.sentry.tombstone.report-historical` manifest option to enable historical tombstone reporting via `AndroidManifest.xml` `<meta-data>` ([#5683](https://github.com/getsentry/sentry-java/pull/5683))
 
 ### Fixes
@@ -82,6 +85,12 @@
 - Remove executor prewarm during SDK init ([#5681](https://github.com/getsentry/sentry-java/pull/5681))
   - The single-threaded `SentryExecutorService` queued the prewarm work ahead of the first useful task, so it could only delay init work, never speed it up; the thread and class loading it warmed are paid identically by the first real task submitted right after.
 
+### Dependencies
+
+- Bump Native SDK from v0.15.2 to v0.15.3 ([#5623](https://github.com/getsentry/sentry-java/pull/5623))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0153)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.15.2...0.15.3)
+
 ## 8.47.0
 
 ### Behavioral Changes
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index 424a283c7d2..adebedf2700 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -391,6 +391,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun getDebugImagesLoader ()Lio/sentry/android/core/IDebugImagesLoader;
 	public fun getFrameMetricsCollector ()Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;
 	public fun getNativeSdkName ()Ljava/lang/String;
+	public fun getNdkAppHangTimeoutIntervalMillis ()J
 	public fun getNdkHandlerStrategy ()I
 	public fun getScreenshot ()Lio/sentry/android/core/SentryScreenshotOptions;
 	public fun getStartupCrashDurationThresholdMillis ()J
@@ -412,6 +413,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun isEnableAutoTraceIdGeneration ()Z
 	public fun isEnableFramesTracking ()Z
 	public fun isEnableNdk ()Z
+	public fun isEnableNdkAppHangTracking ()Z
 	public fun isEnableNetworkEventBreadcrumbs ()Z
 	public fun isEnablePerformanceV2 ()Z
 	public fun isEnableRootCheck ()Z
@@ -444,6 +446,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun setEnableAutoTraceIdGeneration (Z)V
 	public fun setEnableFramesTracking (Z)V
 	public fun setEnableNdk (Z)V
+	public fun setEnableNdkAppHangTracking (Z)V
 	public fun setEnableNetworkEventBreadcrumbs (Z)V
 	public fun setEnablePerformanceV2 (Z)V
 	public fun setEnableRootCheck (Z)V
@@ -454,6 +457,7 @@ public final class io/sentry/android/core/SentryAndroidOptions : io/sentry/Sentr
 	public fun setFrameMetricsCollector (Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;)V
 	public fun setNativeHandlerStrategy (Lio/sentry/android/core/NdkHandlerStrategy;)V
 	public fun setNativeSdkName (Ljava/lang/String;)V
+	public fun setNdkAppHangTimeoutIntervalMillis (J)V
 	public fun setReportHistoricalAnrs (Z)V
 	public fun setReportHistoricalTombstones (Z)V
 	public fun setTombstoneEnabled (Z)V
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 6ae9be3e8b0..7a9cd8a4d13 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -35,6 +35,11 @@ final class ManifestMetadataReader {
   static final String ANR_ATTACH_THREAD_DUMPS = "io.sentry.anr.attach-thread-dumps";
   static final String ANR_REPORT_HISTORICAL = "io.sentry.anr.report-historical";
 
+  static final String NDK_APP_HANG_TRACKING_ENABLE = "io.sentry.ndk.app-hang.enable";
+
+  static final String NDK_APP_HANG_TIMEOUT_INTERVAL_MILLIS =
+      "io.sentry.ndk.app-hang.timeout-interval-millis";
+
   static final String TOMBSTONE_ENABLE = "io.sentry.tombstone.enable";
   static final String TOMBSTONE_ATTACH_RAW = "io.sentry.tombstone.attach-raw";
   static final String TOMBSTONE_REPORT_HISTORICAL = "io.sentry.tombstone.report-historical";
@@ -271,6 +276,20 @@ static void applyMetadata(
         options.setReportHistoricalAnrs(
             readBool(metadata, logger, ANR_REPORT_HISTORICAL, options.isReportHistoricalAnrs()));
 
+        options.setEnableNdkAppHangTracking(
+            readBool(
+                metadata,
+                logger,
+                NDK_APP_HANG_TRACKING_ENABLE,
+                options.isEnableNdkAppHangTracking()));
+
+        options.setNdkAppHangTimeoutIntervalMillis(
+            readLong(
+                metadata,
+                logger,
+                NDK_APP_HANG_TIMEOUT_INTERVAL_MILLIS,
+                options.getNdkAppHangTimeoutIntervalMillis()));
+
         final @Nullable String dsn = readString(metadata, logger, DSN, options.getDsn());
         final boolean enabled = readBool(metadata, logger, ENABLE_SENTRY, options.isEnabled());
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
index ed07c4edaaf..615db97a28d 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroidOptions.java
@@ -37,6 +37,22 @@ public final class SentryAndroidOptions extends SentryOptions {
   /** Enable or disable ANR on Debug mode Default is disabled Used by AnrIntegration */
   private boolean anrReportInDebug = false;
 
+  /**
+   * Enable or disable in-process, heartbeat-based app-hang detection in sentry-native. Default is
+   * disabled. When enabled, sentry-native's background watchdog captures an app-hang event if no
+   * heartbeat is received within {@link #ndkAppHangTimeoutIntervalMillis} on the monitored thread.
+   *
+   * <p>This is intended for downstream/hybrid SDKs that emit the heartbeat by calling the native
+   * {@code sentry_app_hang_heartbeat()} from their main thread. It is independent of the JVM-based
+   * {@link #anrEnabled} ANR detection.
+   */
+  private boolean enableNdkAppHangTracking = false;
+
+  /**
+   * The app-hang detection timeout interval in millis used by sentry-native. Default is 5000 = 5s.
+   */
+  private long ndkAppHangTimeoutIntervalMillis = 5000;
+
   /**
    * Enable or disable automatic breadcrumbs for Activity lifecycle. Using
    * Application.ActivityLifecycleCallbacks
@@ -338,6 +354,50 @@ public void setAnrReportInDebug(boolean anrReportInDebug) {
     this.anrReportInDebug = anrReportInDebug;
   }
 
+  /**
+   * Checks if heartbeat-based app-hang detection in sentry-native is enabled. Default is disabled.
+   *
+   * @return true if enabled or false otherwise
+   */
+  @ApiStatus.Experimental
+  public boolean isEnableNdkAppHangTracking() {
+    return enableNdkAppHangTracking;
+  }
+
+  /**
+   * Enables or disables heartbeat-based app-hang detection in sentry-native. Default is disabled.
+   * Requires the NDK integration to be present and emitting heartbeats via the native {@code
+   * sentry_app_hang_heartbeat()}.
+   *
+   * @param enableNdkAppHangTracking true for enabled and false for disabled
+   */
+  @ApiStatus.Experimental
+  public void setEnableNdkAppHangTracking(boolean enableNdkAppHangTracking) {
+    this.enableNdkAppHangTracking = enableNdkAppHangTracking;
+  }
+
+  /**
+   * Returns the app-hang detection timeout interval in millis used by sentry-native. Default is
+   * 5000 = 5s.
+   *
+   * @return the timeout in millis
+   */
+  @ApiStatus.Experimental
+  public long getNdkAppHangTimeoutIntervalMillis() {
+    return ndkAppHangTimeoutIntervalMillis;
+  }
+
+  /**
+   * Sets the app-hang detection timeout interval in millis used by sentry-native. Default is 5000 =
+   * 5s.
+   *
+   * @param ndkAppHangTimeoutIntervalMillis the timeout interval in millis
+   */
+  @ApiStatus.Experimental
+  public void setNdkAppHangTimeoutIntervalMillis(long ndkAppHangTimeoutIntervalMillis) {
+    this.ndkAppHangTimeoutIntervalMillis = ndkAppHangTimeoutIntervalMillis;
+  }
+
   /**
    * Sets Tombstone reporting (ApplicationExitInfo.REASON_CRASH_NATIVE) to enabled or disabled.
    *
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index 94da78fcfaa..d0dbd1deb50 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -288,6 +288,56 @@ class ManifestMetadataReaderTest {
     assertEquals(false, fixture.options.isAttachAnrThreadDump)
   }
 
+  @Test
+  fun `applyMetadata reads app hang tracking enabled to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.NDK_APP_HANG_TRACKING_ENABLE to true)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(true, fixture.options.isEnableNdkAppHangTracking)
+  }
+
+  @Test
+  fun `applyMetadata reads app hang tracking enabled to options and keeps default`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(false, fixture.options.isEnableNdkAppHangTracking)
+  }
+
+  @Test
+  fun `applyMetadata reads app hang timeout interval to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.NDK_APP_HANG_TIMEOUT_INTERVAL_MILLIS to 1000)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(1000.toLong(), fixture.options.ndkAppHangTimeoutIntervalMillis)
+  }
+
+  @Test
+  fun `applyMetadata reads app hang timeout interval to options and keeps default`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(5000.toLong(), fixture.options.ndkAppHangTimeoutIntervalMillis)
+  }
+
   @Test
   fun `applyMetadata reads tombstone attach raw to options`() {
     // Arrange
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt
index 0eec9502702..94857b91058 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidOptionsTest.kt
@@ -239,6 +239,13 @@ class SentryAndroidOptionsTest {
     sentryOptions.anrProfilingSampleRate = 2.0
   }
 
+  @Test
+  fun `app hang tracking is disabled by default with a 5s timeout`() {
+    val sentryOptions = SentryAndroidOptions()
+    assertFalse(sentryOptions.isEnableNdkAppHangTracking)
+    assertEquals(5000L, sentryOptions.ndkAppHangTimeoutIntervalMillis)
+  }
+
   private class CustomDebugImagesLoader : IDebugImagesLoader {
     override fun loadDebugImages(): List<DebugImage>? = null
 
diff --git a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java
index 9d6d64a1236..fae652f7a64 100644
--- a/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java
+++ b/sentry-android-ndk/src/main/java/io/sentry/android/ndk/SentryNdk.java
@@ -73,6 +73,9 @@ public static void init(@NotNull final SentryAndroidOptions options) {
           ndkOptions.setTracesSampleRate(tracesSampleRate.floatValue());
         }
 
+        ndkOptions.setEnableAppHangTracking(options.isEnableNdkAppHangTracking());
+        ndkOptions.setAppHangTimeoutMillis(options.getNdkAppHangTimeoutIntervalMillis());
+
         //noinspection UnstableApiUsage
         io.sentry.ndk.SentryNdk.init(ndkOptions);
 
diff --git a/sentry-android-ndk/src/test/java/io/sentry/android/ndk/SentryNdkTest.kt b/sentry-android-ndk/src/test/java/io/sentry/android/ndk/SentryNdkTest.kt
index c9f540f0afa..d9b332ac185 100644
--- a/sentry-android-ndk/src/test/java/io/sentry/android/ndk/SentryNdkTest.kt
+++ b/sentry-android-ndk/src/test/java/io/sentry/android/ndk/SentryNdkTest.kt
@@ -3,7 +3,9 @@ package io.sentry.android.ndk
 import io.sentry.android.core.SentryAndroidOptions
 import io.sentry.ndk.NdkOptions
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
 import org.junit.Test
 import org.mockito.Mockito
 import org.mockito.kotlin.any
@@ -68,4 +70,30 @@ class SentryNdkTest {
       assertEquals(0.75f, fixture.capturedOptions!!.tracesSampleRate, 0.0001f)
     }
   }
+
+  @Test
+  fun `SentryNdk does not enable app hang tracking by default`() {
+    fixture.getSut {
+      assertNotNull(fixture.capturedOptions)
+      assertFalse(fixture.capturedOptions!!.isEnableAppHangTracking)
+      assertEquals(5000L, fixture.capturedOptions!!.appHangTimeoutMillis)
+    }
+  }
+
+  @Test
+  fun `SentryNdk propagates app hang tracking options`() {
+    fixture.getSut(
+      options =
+        SentryAndroidOptions().apply {
+          dsn = "https://key@sentry.io/proj"
+          cacheDirPath = "/cache"
+          isEnableNdkAppHangTracking = true
+          ndkAppHangTimeoutIntervalMillis = 2000
+        }
+    ) {
+      assertNotNull(fixture.capturedOptions)
+      assertTrue(fixture.capturedOptions!!.isEnableAppHangTracking)
+      assertEquals(2000L, fixture.capturedOptions!!.appHangTimeoutMillis)
+    }
+  }
 }
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index 02934b1ed7d..262b3a93034 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -992,7 +992,7 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
     }
 
     if (shouldApplyScopeData(transaction, hint)) {
-      transaction = applyScope(transaction, scope);
+      transaction = applyScope(transaction, scope, HintUtils.hasType(hint, Cached.class));
 
       if (transaction != null && scope != null) {
         transaction = processTransaction(transaction, hint, scope.getEventProcessors());
@@ -1407,7 +1407,7 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
   private @Nullable SentryEvent applyScope(
       @NotNull SentryEvent event, final @Nullable IScope scope, final @NotNull Hint hint) {
     if (scope != null) {
-      applyScope(event, scope);
+      applyScope(event, scope, HintUtils.hasType(hint, Cached.class));
 
       if (event.getTransaction() == null) {
         event.setTransaction(scope.getTransactionName());
@@ -1539,7 +1539,7 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
   }
 
   private <T extends SentryBaseEvent> @NotNull T applyScope(
-      final @NotNull T sentryBaseEvent, final @Nullable IScope scope) {
+      final @NotNull T sentryBaseEvent, final @Nullable IScope scope, final boolean isCached) {
     if (scope != null) {
       if (sentryBaseEvent.getRequest() == null) {
         sentryBaseEvent.setRequest(scope.getRequest());
@@ -1558,7 +1558,9 @@ public void captureBatchedMetricsEvents(final @NotNull SentryMetricsEvents metri
       }
       if (sentryBaseEvent.getBreadcrumbs() == null) {
         sentryBaseEvent.setBreadcrumbs(new ArrayList<>(scope.getBreadcrumbs()));
-      } else {
+      } else if (!isCached) {
+        // A Cached event comes from the outbox and already carries its own breadcrumbs (e.g. native
+        // events written by sentry-native). Appending the scope's breadcrumbs would duplicate them.
         sortBreadcrumbsByDate(sentryBaseEvent, scope.getBreadcrumbs());
       }
       if (sentryBaseEvent.getExtras() == null) {
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index 5b407bfef3d..ea64675570d 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -649,6 +649,52 @@ class SentryClientTest {
     }
   }
 
+  @Test
+  fun `when event is cached, scope breadcrumbs are not merged into the event breadcrumbs`() {
+    val scopeCrumb = Breadcrumb(DateUtils.getDateTime("2020-03-27T08:52:58.001Z"))
+    val scope = Scope(SentryOptions()).apply { addBreadcrumb(scopeCrumb) }
+
+    val sut = fixture.getSut()
+
+    val eventCrumb = Breadcrumb(DateUtils.getDateTime("2020-03-27T08:52:58.003Z"))
+    val event = SentryEvent().apply { breadcrumbs = mutableListOf(eventCrumb) }
+
+    val hints = HintUtils.createWithTypeCheckHint(CachedHint())
+    sut.captureEvent(event, scope, hints)
+
+    assertNotNull(event.breadcrumbs) {
+      assertEquals(1, it.size)
+      assertSame(eventCrumb, it[0])
+    }
+  }
+
+  @Test
+  fun `when transaction is cached, scope breadcrumbs are not merged into the transaction breadcrumbs`() {
+    val sut = fixture.getSut()
+    val scope = Scope(fixture.sentryOptions)
+    scope.addBreadcrumb(Breadcrumb("from scope"))
+
+    val transaction = SentryTransaction(fixture.sentryTracer)
+    transaction.breadcrumbs = mutableListOf(Breadcrumb("from transaction"))
+
+    val hints = HintUtils.createWithTypeCheckHint(CachedHint())
+    sut.captureTransaction(transaction, scope, hints)
+
+    verify(fixture.transport)
+      .send(
+        check { envelope ->
+          val sent = envelope.items.first().getTransaction(fixture.sentryOptions.serializer)
+          assertNotNull(sent) {
+            assertNotNull(it.breadcrumbs) { breadcrumbs ->
+              assertEquals(1, breadcrumbs.size)
+              assertEquals("from transaction", breadcrumbs.first().message)
+            }
+          }
+        },
+        anyOrNull(),
+      )
+  }
+
   @Test
   fun `when captureEvent with scope, event data has priority over scope but level and it should append extras, tags and breadcrumbs`() {
     val event = createEvent()

From 98106dd4bc11d056c20427c3e65bf8abb9d4ccc3 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Mon, 13 Jul 2026 14:30:44 +0200
Subject: [PATCH 290/391] fix(core): Prevent lost wakeups in batch processors
 (#5756)

* fix(core): Prevent lost wakeups in batch processors

Coordinate log and metric flush scheduling through an atomic state transition. This ensures events added while a flush completes always have a pending task instead of relying on the running Future's completion state.

Fixes #5739

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../sentry/logger/LoggerBatchProcessor.java   | 56 +++++++-----------
 .../sentry/metrics/MetricsBatchProcessor.java | 58 ++++++++-----------
 .../sentry/logger/LoggerBatchProcessorTest.kt | 22 +++++++
 .../metrics/MetricsBatchProcessorTest.kt      | 23 ++++++++
 5 files changed, 92 insertions(+), 68 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a3baff8d6b2..a6600fda921 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,7 @@
 
 ### Fixes
 
+- Prevent logs and metrics from remaining queued after a flush scheduling race ([#5756](https://github.com/getsentry/sentry-java/pull/5756))
 - Fix main thread identification for tombstone (native crash) events ([#5742](https://github.com/getsentry/sentry-java/pull/5742))
 
 ### Dependencies
diff --git a/sentry/src/main/java/io/sentry/logger/LoggerBatchProcessor.java b/sentry/src/main/java/io/sentry/logger/LoggerBatchProcessor.java
index 81ae5b73c1a..71877c21dae 100644
--- a/sentry/src/main/java/io/sentry/logger/LoggerBatchProcessor.java
+++ b/sentry/src/main/java/io/sentry/logger/LoggerBatchProcessor.java
@@ -4,7 +4,6 @@
 import io.sentry.DataCategory;
 import io.sentry.ISentryClient;
 import io.sentry.ISentryExecutorService;
-import io.sentry.ISentryLifecycleToken;
 import io.sentry.SentryExecutorService;
 import io.sentry.SentryLevel;
 import io.sentry.SentryLogEvent;
@@ -12,15 +11,14 @@
 import io.sentry.SentryOptions;
 import io.sentry.clientreport.DiscardReason;
 import io.sentry.transport.ReusableCountLatch;
-import io.sentry.util.AutoClosableReentrantLock;
 import io.sentry.util.JsonSerializationUtils;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -37,9 +35,7 @@ public class LoggerBatchProcessor implements ILoggerBatchProcessor {
   private final @NotNull ISentryClient client;
   private final @NotNull Queue<SentryLogEvent> queue;
   private final @NotNull ISentryExecutorService executorService;
-  private volatile @Nullable Future<?> scheduledFlush;
-  private final @NotNull AutoClosableReentrantLock scheduleLock = new AutoClosableReentrantLock();
-  private volatile boolean hasScheduled = false;
+  private final @NotNull AtomicBoolean hasScheduled = new AtomicBoolean(false);
   private volatile boolean isShuttingDown = false;
 
   private final @NotNull ReusableCountLatch pendingCount = new ReusableCountLatch();
@@ -79,7 +75,7 @@ public void add(final @NotNull SentryLogEvent logEvent) {
     }
     pendingCount.increment();
     queue.offer(logEvent);
-    maybeSchedule(false, false);
+    maybeSchedule(false);
   }
 
   @SuppressWarnings("FutureReturnValueIgnored")
@@ -87,7 +83,7 @@ public void add(final @NotNull SentryLogEvent logEvent) {
   public void close(final boolean isRestarting) {
     isShuttingDown = true;
     if (isRestarting) {
-      maybeSchedule(true, true);
+      maybeSchedule(true);
       executorService.submit(() -> executorService.close(options.getShutdownTimeoutMillis()));
     } else {
       executorService.close(options.getShutdownTimeoutMillis());
@@ -97,33 +93,28 @@ public void close(final boolean isRestarting) {
     }
   }
 
-  private void maybeSchedule(boolean forceSchedule, boolean immediately) {
-    if (hasScheduled && !forceSchedule) {
+  @SuppressWarnings("FutureReturnValueIgnored")
+  private void maybeSchedule(boolean immediately) {
+    if (immediately) {
+      // any already scheduled task may be far in the future, we want to schedule something that
+      // runs right away
+      hasScheduled.set(true);
+    } else if (!hasScheduled.compareAndSet(false, true)) {
+      // was already true, no need to schedule again
       return;
     }
-    try (final @NotNull ISentryLifecycleToken ignored = scheduleLock.acquire()) {
-      final @Nullable Future<?> latestScheduledFlush = scheduledFlush;
-      if (forceSchedule
-          || latestScheduledFlush == null
-          || latestScheduledFlush.isDone()
-          || latestScheduledFlush.isCancelled()) {
-        hasScheduled = true;
-        final int flushAfterMs = immediately ? 0 : FLUSH_AFTER_MS;
-        try {
-          scheduledFlush = executorService.schedule(new BatchRunnable(), flushAfterMs);
-        } catch (RejectedExecutionException e) {
-          hasScheduled = false;
-          options
-              .getLogger()
-              .log(SentryLevel.WARNING, "Logs batch processor flush task rejected", e);
-        }
-      }
+    final int flushAfterMs = immediately ? 0 : FLUSH_AFTER_MS;
+    try {
+      executorService.schedule(new BatchRunnable(), flushAfterMs);
+    } catch (RejectedExecutionException e) {
+      hasScheduled.set(false);
+      options.getLogger().log(SentryLevel.WARNING, "Logs batch processor flush task rejected", e);
     }
   }
 
   @Override
   public void flush(long timeoutMillis) {
-    maybeSchedule(true, true);
+    maybeSchedule(true);
     try {
       pendingCount.waitTillZero(timeoutMillis, TimeUnit.MILLISECONDS);
     } catch (InterruptedException e) {
@@ -134,12 +125,9 @@ public void flush(long timeoutMillis) {
 
   private void flush() {
     flushInternal();
-    try (final @NotNull ISentryLifecycleToken ignored = scheduleLock.acquire()) {
-      if (!queue.isEmpty()) {
-        maybeSchedule(true, false);
-      } else {
-        hasScheduled = false;
-      }
+    hasScheduled.set(false);
+    if (!queue.isEmpty()) {
+      maybeSchedule(false);
     }
   }
 
diff --git a/sentry/src/main/java/io/sentry/metrics/MetricsBatchProcessor.java b/sentry/src/main/java/io/sentry/metrics/MetricsBatchProcessor.java
index 2d5c78e5e89..3c744dbe3c5 100644
--- a/sentry/src/main/java/io/sentry/metrics/MetricsBatchProcessor.java
+++ b/sentry/src/main/java/io/sentry/metrics/MetricsBatchProcessor.java
@@ -4,7 +4,6 @@
 import io.sentry.DataCategory;
 import io.sentry.ISentryClient;
 import io.sentry.ISentryExecutorService;
-import io.sentry.ISentryLifecycleToken;
 import io.sentry.SentryExecutorService;
 import io.sentry.SentryLevel;
 import io.sentry.SentryMetricsEvent;
@@ -12,15 +11,14 @@
 import io.sentry.SentryOptions;
 import io.sentry.clientreport.DiscardReason;
 import io.sentry.transport.ReusableCountLatch;
-import io.sentry.util.AutoClosableReentrantLock;
 import io.sentry.util.JsonSerializationUtils;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;
-import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -35,9 +33,7 @@ public class MetricsBatchProcessor implements IMetricsBatchProcessor {
   private final @NotNull ISentryClient client;
   private final @NotNull Queue<SentryMetricsEvent> queue;
   private final @NotNull ISentryExecutorService executorService;
-  private volatile @Nullable Future<?> scheduledFlush;
-  private final @NotNull AutoClosableReentrantLock scheduleLock = new AutoClosableReentrantLock();
-  private volatile boolean hasScheduled = false;
+  private final @NotNull AtomicBoolean hasScheduled = new AtomicBoolean(false);
   private volatile boolean isShuttingDown = false;
 
   private final @NotNull ReusableCountLatch pendingCount = new ReusableCountLatch();
@@ -69,7 +65,7 @@ public void add(final @NotNull SentryMetricsEvent metricsEvent) {
     }
     pendingCount.increment();
     queue.offer(metricsEvent);
-    maybeSchedule(false, false);
+    maybeSchedule(false);
   }
 
   @SuppressWarnings("FutureReturnValueIgnored")
@@ -77,7 +73,7 @@ public void add(final @NotNull SentryMetricsEvent metricsEvent) {
   public void close(final boolean isRestarting) {
     isShuttingDown = true;
     if (isRestarting) {
-      maybeSchedule(true, true);
+      maybeSchedule(true);
       executorService.submit(() -> executorService.close(options.getShutdownTimeoutMillis()));
     } else {
       executorService.close(options.getShutdownTimeoutMillis());
@@ -87,33 +83,30 @@ public void close(final boolean isRestarting) {
     }
   }
 
-  private void maybeSchedule(boolean forceSchedule, boolean immediately) {
-    if (hasScheduled && !forceSchedule) {
+  @SuppressWarnings("FutureReturnValueIgnored")
+  private void maybeSchedule(boolean immediately) {
+    if (immediately) {
+      // any already scheduled task may be far in the future, we want to schedule something that
+      // runs right away
+      hasScheduled.set(true);
+    } else if (!hasScheduled.compareAndSet(false, true)) {
+      // was already true, no need to schedule again
       return;
     }
-    try (final @NotNull ISentryLifecycleToken ignored = scheduleLock.acquire()) {
-      final @Nullable Future<?> latestScheduledFlush = scheduledFlush;
-      if (forceSchedule
-          || latestScheduledFlush == null
-          || latestScheduledFlush.isDone()
-          || latestScheduledFlush.isCancelled()) {
-        hasScheduled = true;
-        final int flushAfterMs = immediately ? 0 : FLUSH_AFTER_MS;
-        try {
-          scheduledFlush = executorService.schedule(new BatchRunnable(), flushAfterMs);
-        } catch (RejectedExecutionException e) {
-          hasScheduled = false;
-          options
-              .getLogger()
-              .log(SentryLevel.WARNING, "Metrics batch processor flush task rejected", e);
-        }
-      }
+    final int flushAfterMs = immediately ? 0 : FLUSH_AFTER_MS;
+    try {
+      executorService.schedule(new BatchRunnable(), flushAfterMs);
+    } catch (RejectedExecutionException e) {
+      hasScheduled.set(false);
+      options
+          .getLogger()
+          .log(SentryLevel.WARNING, "Metrics batch processor flush task rejected", e);
     }
   }
 
   @Override
   public void flush(long timeoutMillis) {
-    maybeSchedule(true, true);
+    maybeSchedule(true);
     try {
       pendingCount.waitTillZero(timeoutMillis, TimeUnit.MILLISECONDS);
     } catch (InterruptedException e) {
@@ -124,12 +117,9 @@ public void flush(long timeoutMillis) {
 
   private void flush() {
     flushInternal();
-    try (final @NotNull ISentryLifecycleToken ignored = scheduleLock.acquire()) {
-      if (!queue.isEmpty()) {
-        maybeSchedule(true, false);
-      } else {
-        hasScheduled = false;
-      }
+    hasScheduled.set(false);
+    if (!queue.isEmpty()) {
+      maybeSchedule(false);
     }
   }
 
diff --git a/sentry/src/test/java/io/sentry/logger/LoggerBatchProcessorTest.kt b/sentry/src/test/java/io/sentry/logger/LoggerBatchProcessorTest.kt
index 73f2f03ebc3..01b8afdb4a3 100644
--- a/sentry/src/test/java/io/sentry/logger/LoggerBatchProcessorTest.kt
+++ b/sentry/src/test/java/io/sentry/logger/LoggerBatchProcessorTest.kt
@@ -1,5 +1,6 @@
 package io.sentry.logger
 
+import com.google.common.truth.Truth.assertThat
 import io.sentry.DataCategory
 import io.sentry.ISentryClient
 import io.sentry.SentryLogEvent
@@ -21,9 +22,30 @@ import kotlin.test.assertTrue
 import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.atLeast
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 
 class LoggerBatchProcessorTest {
+  @Test
+  fun `schedules another flush after previous flush has run`() {
+    val mockClient = mock<ISentryClient>()
+    val mockExecutor = DeferredExecutorService()
+    val processor = LoggerBatchProcessor(SentryOptions(), mockClient, mockExecutor)
+
+    processor.add(SentryLogEvent(SentryId(), SentryNanotimeDate(), "first", SentryLogLevel.INFO))
+    mockExecutor.runAll()
+
+    processor.add(SentryLogEvent(SentryId(), SentryNanotimeDate(), "second", SentryLogLevel.INFO))
+    assertThat(mockExecutor.hasScheduledRunnables()).isTrue()
+    mockExecutor.runAll()
+
+    val captor = argumentCaptor<SentryLogEvents>()
+    verify(mockClient, times(2)).captureBatchedLogEvents(captor.capture())
+    assertThat(captor.allValues.flatMap { it.items }.map { it.body })
+      .containsExactly("first", "second")
+      .inOrder()
+  }
+
   @Test
   fun `drops log events after reaching MAX_QUEUE_SIZE limit`() {
     // given
diff --git a/sentry/src/test/java/io/sentry/metrics/MetricsBatchProcessorTest.kt b/sentry/src/test/java/io/sentry/metrics/MetricsBatchProcessorTest.kt
index 5ca1d0fe87a..d8320d9b1a6 100644
--- a/sentry/src/test/java/io/sentry/metrics/MetricsBatchProcessorTest.kt
+++ b/sentry/src/test/java/io/sentry/metrics/MetricsBatchProcessorTest.kt
@@ -1,5 +1,6 @@
 package io.sentry.metrics
 
+import com.google.common.truth.Truth.assertThat
 import io.sentry.DataCategory
 import io.sentry.ISentryClient
 import io.sentry.SentryMetricsEvent
@@ -20,9 +21,31 @@ import kotlin.test.assertTrue
 import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.atLeast
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 
 class MetricsBatchProcessorTest {
+  @Test
+  fun `schedules another flush after previous flush has run`() {
+    val mockClient = mock<ISentryClient>()
+    val mockExecutor = DeferredExecutorService()
+    val processor = MetricsBatchProcessor(SentryOptions(), mockClient)
+    processor.injectForField("executorService", mockExecutor)
+
+    processor.add(SentryMetricsEvent(SentryId(), SentryNanotimeDate(), "first", "gauge", 1.0))
+    mockExecutor.runAll()
+
+    processor.add(SentryMetricsEvent(SentryId(), SentryNanotimeDate(), "second", "gauge", 2.0))
+    assertThat(mockExecutor.hasScheduledRunnables()).isTrue()
+    mockExecutor.runAll()
+
+    val captor = argumentCaptor<SentryMetricsEvents>()
+    verify(mockClient, times(2)).captureBatchedMetricsEvents(captor.capture())
+    assertThat(captor.allValues.flatMap { it.items }.map { it.name })
+      .containsExactly("first", "second")
+      .inOrder()
+  }
+
   @Test
   fun `drops metrics events after reaching MAX_QUEUE_SIZE limit`() {
     // given

From f232e4f470c4dfd4e436b29411d0946b0974a1cb Mon Sep 17 00:00:00 2001
From: "sentry-junior[bot]"
 <264270552+sentry-junior[bot]@users.noreply.github.com>
Date: Mon, 13 Jul 2026 20:09:32 +0200
Subject: [PATCH 291/391] docs: Improve PR template guidance (#5757)

Co-Authored-By: roman <roman.zavarnitsyn@sentry.io>

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
---
 .github/pull_request_template.md | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index e4a12165077..baa2dad44a2 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -1,5 +1,5 @@
 ## :scroll: Description
-<!--- Describe your changes in detail -->
+<!--- Describe your changes in detail and optionally add screenshots -->
 
 
 ## :bulb: Motivation and Context
@@ -12,6 +12,10 @@
 -->
 
 ## :green_heart: How did you test it?
+<!---
+Include a link to Sentry when applicable:
+* Link to Sentry: <LINK>
+-->
 
 
 ## :pencil: Checklist

From 31c558ecbc0ceee6d01fe587848d7307f7c78de1 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Mon, 13 Jul 2026 21:53:48 +0200
Subject: [PATCH 292/391] fix(replay): Preserve segment ID after
 buffer-to-session conversion (#5753)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(replay): Preserve segment ID after buffer-to-session conversion

After a buffer-to-session conversion, the replay type stays BUFFER
but the segment counter reflects the real sequence. If the app
crashes and finalizePreviousReplay recovers the last segment,
fromDisk() was normalizing the segment ID to 0 for all BUFFER
replays, creating a duplicate segment 0 that overwrites the original.

Add a persisted isFlushed flag set when the buffer is successfully
flushed. fromDisk() now only normalizes to 0 when the buffer was
never flushed (no segments were ever sent to the server).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* changelog

* Apply suggestion from @romtsn

* Add comment explaining isFlushed flag purpose

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Use persisted timestamp for flushed buffer recovery

After buffer-to-session conversion, use the persisted segmentTimestamp
(which chains with previous segments) instead of the first frame
timestamp, avoiding gaps in the recovered segment timeline.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Revert timestamp normalization change

The gap from using first-frame timestamp vs persisted segmentTimestamp
is at most ~1s (1/frameRate) — negligible for crash recovery.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../io/sentry/android/replay/ReplayCache.kt   |  8 +++--
 .../android/replay/ReplayIntegration.kt       |  1 +
 .../replay/capture/BaseCaptureStrategy.kt     |  6 ++++
 .../replay/capture/BufferCaptureStrategy.kt   |  1 -
 .../android/replay/capture/CaptureStrategy.kt |  1 +
 .../sentry/android/replay/ReplayCacheTest.kt  | 36 ++++++++++++++++++-
 7 files changed, 50 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a6600fda921..393f4f8da3e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -30,6 +30,7 @@
 
 ### Fixes
 
+- Session Replay: Fix first recording segment missing for replays in `buffer` mode ([#5753](https://github.com/getsentry/sentry-java/pull/5753))
 - Prevent logs and metrics from remaining queued after a flush scheduling race ([#5756](https://github.com/getsentry/sentry-java/pull/5756))
 - Fix main thread identification for tombstone (native crash) events ([#5742](https://github.com/getsentry/sentry-java/pull/5742))
 
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
index b3b9edae055..b54177bca9b 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
@@ -317,6 +317,7 @@ public class ReplayCache(private val options: SentryOptions, private val replayI
     internal const val SEGMENT_KEY_REPLAY_SCREEN_AT_START = "replay.screen-at-start"
     internal const val SEGMENT_KEY_REPLAY_RECORDING = "replay.recording"
     internal const val SEGMENT_KEY_ID = "segment.id"
+    internal const val SEGMENT_KEY_FLUSHED = "replay.flushed"
 
     fun makeReplayCacheDir(options: SentryOptions, replayId: SentryId): File? =
       if (options.cacheDirPath.isNullOrEmpty()) {
@@ -415,8 +416,11 @@ public class ReplayCache(private val options: SentryOptions, private val replayI
       }
 
       cache.frames.sortBy { it.timestamp }
-      // TODO: this should be removed when we start sending buffered segments on next launch
-      val normalizedSegmentId = if (replayType == SESSION) segmentId else 0
+      val wasFlushed = lastSegment[SEGMENT_KEY_FLUSHED]?.toBooleanStrictOrNull() == true
+      // In buffer mode, if the buffer was never flushed (no error triggered captureReplay),
+      // no segments were ever sent, so we normalize to 0. After a flush + conversion to
+      // session mode, the persisted segmentId is the real sequence number.
+      val normalizedSegmentId = if (replayType == SESSION || wasFlushed) segmentId else 0
       val normalizedTimestamp =
         if (replayType == SESSION) {
           segmentTimestamp
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
index 612517438f6..bae0e411795 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
@@ -261,6 +261,7 @@ public class ReplayIntegration(
       onSegmentSent = { newTimestamp ->
         captureStrategy?.currentSegment = captureStrategy?.currentSegment!! + 1
         captureStrategy?.segmentTimestamp = newTimestamp
+        captureStrategy?.isFlushed = true
       },
     )
     captureStrategy = captureStrategy?.convert()
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
index 6bb58c5e2a2..fbc0ccfd4bc 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
@@ -13,6 +13,7 @@ import io.sentry.SentryReplayEvent.ReplayType.BUFFER
 import io.sentry.SentryReplayEvent.ReplayType.SESSION
 import io.sentry.android.replay.ReplayCache
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_BIT_RATE
+import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_FLUSHED
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_FRAME_RATE
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_HEIGHT
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_ID
@@ -89,6 +90,11 @@ internal abstract class BaseCaptureStrategy(
     get() = cache?.replayCacheDir
 
   override var replayType by persistableAtomic<ReplayType>(propertyName = SEGMENT_KEY_REPLAY_TYPE)
+  // Tracks whether the buffer was flushed (segments sent to server). Used by fromDisk()
+  // to decide whether to normalize the segment ID to 0 on crash recovery: if never flushed,
+  // no segments reached the server, so the recovered segment must be 0.
+  override var isFlushed: Boolean by
+    persistableAtomic(initialValue = false, propertyName = SEGMENT_KEY_FLUSHED)
 
   protected val currentEvents: Deque<RRWebEvent> = ConcurrentLinkedDeque()
   private val traceIdsLock = Any()
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
index 0df8a642f63..f6c6f3997ae 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
@@ -105,7 +105,6 @@ internal class BufferCaptureStrategy(
 
       if (segment is ReplaySegment.Created) {
         segment.capture(scopes)
-
         // we only want to increment segment_id in the case of success, but currentSegment
         // might be irrelevant since we changed strategies, so in the callback we increment
         // it on the new strategy already
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt
index 6dc391a15ec..096a93741b2 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt
@@ -29,6 +29,7 @@ internal interface CaptureStrategy {
   val replayCacheDir: File?
   var replayType: ReplayType
   var segmentTimestamp: Date?
+  var isFlushed: Boolean
 
   fun start(segmentId: Int = 0, replayId: SentryId = SentryId(), replayType: ReplayType? = null)
 
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt
index 257941a9114..8b64ca5caeb 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt
@@ -9,6 +9,7 @@ import io.sentry.SentryOptions
 import io.sentry.SentryReplayEvent.ReplayType
 import io.sentry.android.replay.ReplayCache.Companion.ONGOING_SEGMENT
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_BIT_RATE
+import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_FLUSHED
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_FRAME_RATE
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_HEIGHT
 import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_ID
@@ -443,7 +444,7 @@ class ReplayCacheTest {
   }
 
   @Test
-  fun `sets segmentId to 0 for buffer mode`() {
+  fun `sets segmentId to 0 for buffer mode when not flushed`() {
     fixture.options.run { cacheDirPath = tmpDir.newFolder()?.absolutePath }
     val replayId = SentryId()
     val replayCacheFolder =
@@ -474,6 +475,39 @@ class ReplayCacheTest {
     assertEquals(0, lastSegment.id)
   }
 
+  @Test
+  fun `preserves segmentId for buffer mode when already flushed`() {
+    fixture.options.run { cacheDirPath = tmpDir.newFolder()?.absolutePath }
+    val replayId = SentryId()
+    val replayCacheFolder =
+      File(fixture.options.cacheDirPath!!, "replay_$replayId").also { it.mkdirs() }
+    File(replayCacheFolder, ONGOING_SEGMENT).also {
+      it.writeText(
+        """
+                $SEGMENT_KEY_HEIGHT=912
+                $SEGMENT_KEY_WIDTH=416
+                $SEGMENT_KEY_FRAME_RATE=1
+                $SEGMENT_KEY_BIT_RATE=75000
+                $SEGMENT_KEY_ID=5
+                $SEGMENT_KEY_TIMESTAMP=2024-07-11T10:25:21.454Z
+                $SEGMENT_KEY_REPLAY_TYPE=BUFFER
+                $SEGMENT_KEY_FLUSHED=true
+                """
+          .trimIndent()
+      )
+    }
+
+    val screenshot = File(replayCacheFolder, "1720693523997.jpg").also { it.createNewFile() }
+    screenshot.outputStream().use {
+      Bitmap.createBitmap(1, 1, ARGB_8888).compress(JPEG, 80, it)
+      it.flush()
+    }
+
+    val lastSegment = ReplayCache.fromDisk(fixture.options, replayId)!!
+
+    assertEquals(5, lastSegment.id)
+  }
+
   @Test
   fun `when screenshot is corrupted, deletes it immediately`() {
     ShadowBitmapFactory.setAllowInvalidImageData(false)

From c94d7babf5205296c999b719495baddc70c00c63 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Mon, 13 Jul 2026 22:59:22 +0200
Subject: [PATCH 293/391] fix(core): Inject replayId into trace context for
 buffer mode errors (#5754)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(core): Set replayId in DSC for buffer mode error events

In buffer mode, the scope's replayId is empty until captureReplay()
is called. The transaction's baggage is frozen before that, so the
DSC in the envelope header has no replay_id — breaking error-to-replay
linkage.

After captureReplay() sets the replayId on scope, force-set it on
the transaction's frozen baggage via Baggage.forceSetReplayId() so
the envelope header carries the correct replay_id in the DSC. This
matches the JS SDK's approach of updating the DSC after buffer-to-
session conversion.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Add comment explaining forceSetReplayId

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Apply suggestion from @romtsn

* test(core): Verify replayId is force-set on frozen baggage

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(core): Read replayId from scope after captureReplay

Read scope.getReplayId() which is only set when on-error sampling
succeeds. Using ReplayController.getReplayId() would return the
buffer's internal ID even when sampling rejected the replay.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 sentry/api/sentry.api                         |  1 +
 sentry/src/main/java/io/sentry/Baggage.java   | 13 +++++++
 .../src/main/java/io/sentry/SentryClient.java | 12 +++++++
 .../test/java/io/sentry/SentryClientTest.kt   | 34 +++++++++++++++++++
 5 files changed, 61 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 393f4f8da3e..af29b22ccb5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -31,6 +31,7 @@
 ### Fixes
 
 - Session Replay: Fix first recording segment missing for replays in `buffer` mode ([#5753](https://github.com/getsentry/sentry-java/pull/5753))
+- Session Replay: Fix error-to-replay linkage in `buffer` mode ([#5754](https://github.com/getsentry/sentry-java/pull/5754))
 - Prevent logs and metrics from remaining queued after a flush scheduling race ([#5756](https://github.com/getsentry/sentry-java/pull/5756))
 - Fix main thread identification for tombstone (native crash) events ([#5742](https://github.com/getsentry/sentry-java/pull/5742))
 
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index c0b6fec780c..00183bc9b30 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -37,6 +37,7 @@ public final class io/sentry/Baggage {
 	public fun <init> (Lio/sentry/Baggage;)V
 	public fun <init> (Lio/sentry/ILogger;)V
 	public fun <init> (Ljava/util/concurrent/ConcurrentHashMap;Ljava/lang/Double;Ljava/lang/Double;Ljava/lang/String;ZZLio/sentry/ILogger;)V
+	public fun forceSetReplayId (Lio/sentry/protocol/SentryId;)V
 	public fun forceSetSampleRate (Ljava/lang/Double;)V
 	public fun freeze ()V
 	public static fun fromEvent (Lio/sentry/SentryBaseEvent;Ljava/lang/String;Lio/sentry/SentryOptions;)Lio/sentry/Baggage;
diff --git a/sentry/src/main/java/io/sentry/Baggage.java b/sentry/src/main/java/io/sentry/Baggage.java
index 4645df3f3a4..9f0753f8671 100644
--- a/sentry/src/main/java/io/sentry/Baggage.java
+++ b/sentry/src/main/java/io/sentry/Baggage.java
@@ -451,6 +451,19 @@ public void setReplayId(final @Nullable String replayId) {
     set(DSCKeys.REPLAY_ID, replayId);
   }
 
+  /**
+   * Sets replay_id on the baggage bypassing the freeze check. In buffer mode the replay_id is
+   * unknown when the baggage is frozen, so it must be injected after {@link
+   * ReplayController#captureReplay} sets it on scope. This mirrors the JS SDK's <a
+   * href="https://github.com/getsentry/sentry-javascript/blob/develop/packages/replay-internal/src/util/resetReplayIdOnDynamicSamplingContext.ts">setReplayIdOnDynamicSamplingContext</a>.
+   */
+  @ApiStatus.Internal
+  public void forceSetReplayId(final @NotNull SentryId replayId) {
+    if (!SentryId.EMPTY_ID.equals(replayId)) {
+      keyValues.put(DSCKeys.REPLAY_ID, replayId.toString());
+    }
+  }
+
   @ApiStatus.Internal
   public @Nullable String getOrgId() {
     return get(DSCKeys.ORG_ID);
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index 262b3a93034..4889d1629ce 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -250,6 +250,18 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
       }
       if (shouldCaptureReplay) {
         options.getReplayController().captureReplay(event.isCrashed());
+        if (scope != null) {
+          final @Nullable SentryId replayId = scope.getReplayId();
+          if (replayId != null && !replayId.equals(SentryId.EMPTY_ID)) {
+            final @Nullable ITransaction transaction = scope.getTransaction();
+            if (transaction != null) {
+              final @Nullable Baggage baggage = transaction.getSpanContext().getBaggage();
+              if (baggage != null) {
+                baggage.forceSetReplayId(replayId);
+              }
+            }
+          }
+        }
       }
     }
 
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index ea64675570d..f9cf7de567c 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -3331,6 +3331,40 @@ class SentryClientTest {
     assertTrue(terminated == true)
   }
 
+  @Test
+  fun `sets replayId on frozen transaction baggage after captureReplay for error events`() {
+    val replayId = SentryId()
+    fixture.sentryOptions.setReplayController(
+      object : ReplayController by NoOpReplayController.getInstance() {
+        override fun captureReplay(isTerminating: Boolean?) {}
+      }
+    )
+    val sut = fixture.getSut()
+
+    val baggage = Baggage(fixture.sentryOptions.logger)
+    baggage.traceId = SentryId().toString()
+    baggage.freeze()
+
+    val spanContext = SpanContext("op.load")
+    spanContext.baggage = baggage
+    val transaction = mock<ITransaction>()
+    whenever(transaction.spanContext).thenReturn(spanContext)
+    whenever(transaction.traceContext()).thenReturn(baggage.toTraceContext())
+
+    val scope = mock<IScope>()
+    whenever(scope.transaction).thenReturn(transaction)
+    whenever(scope.span).thenReturn(transaction)
+    whenever(scope.replayId).thenReturn(replayId)
+    whenever(scope.breadcrumbs).thenReturn(LinkedList<Breadcrumb>())
+    whenever(scope.extras).thenReturn(emptyMap())
+    whenever(scope.contexts).thenReturn(Contexts())
+    whenever(scope.propagationContext).thenReturn(PropagationContext())
+
+    sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) }, scope)
+
+    assertEquals(replayId.toString(), baggage.getReplayId())
+  }
+
   @Test
   fun `cleans up replay folder for Backfillable replay events`() {
     val dir = File(tmpDir.newFolder().absolutePath)

From c971c0487bc898e7bae1f0b6692f728d7423f567 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 14 Jul 2026 07:31:04 +0200
Subject: [PATCH 294/391] build: Add Java 8 API compatibility checks (#5745)

* build: Add Java 8 API compatibility checks

Apply Animal Sniffer to Java 8 JVM SDK modules and check them against the Codehaus Java 8 runtime signature. This catches references to newer JDK APIs while keeping the existing Android signature checks in place where they already apply.

Refs GH-5741

* build: Extract Animal Sniffer convention plugins

Move shared Java 8 API compatibility configuration into build-logic plugins. Apply the Android-compatible variant where modules also need gummy-bears API checks to reduce duplicated signature setup.

Co-Authored-By: Claude <noreply@anthropic.com>

* build: Use catalog aliases for Animal Sniffer signatures

Move Java 8 signature coordinates into the version catalog and add a shared helper for registering Animal Sniffer signature dependencies.

Co-Authored-By: Claude <noreply@anthropic.com>

* build: Remove Animal Sniffer reflection

Configure Animal Sniffer tasks with the plugin task type directly so ignored classes can be set without reflective method lookup.

Co-Authored-By: Claude <noreply@anthropic.com>

* build: Avoid afterEvaluate for Animal Sniffer config

Configure Animal Sniffer task options directly from the convention extension so the build does not defer configuration with afterEvaluate.

Co-Authored-By: Claude <noreply@anthropic.com>

* build: Make Animal Sniffer extension config-only

Move the task-wiring logic out of SentryAnimalSnifferExtension and into
the plugin. The extension previously held a Project reference and reached
into the animalsnifferMain task on every DSL call, mixing configuration
with application logic.

The extension now only declares intent via managed ListProperty values;
the plugin reads them when configuring the task. This drops the Project
reference (config-cache friendly) and needs no afterEvaluate, since the
task-configuration action runs after the build script is evaluated.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* build: Clarify java18Signature refers to Java 1.8

* build: Rename java18 signature alias to java8 for clarity

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Nelson Osacky <nelson.osacky@sentry.io>
---
 build-logic/build.gradle.kts                  | 14 +++++
 .../gradle/SentryAnimalSnifferPlugin.kt       | 57 +++++++++++++++++++
 gradle/libs.versions.toml                     |  6 +-
 sentry-apache-http-client-5/build.gradle.kts  |  1 +
 sentry-apollo-3/build.gradle.kts              |  7 +--
 sentry-apollo-4/build.gradle.kts              |  7 +--
 sentry-apollo/build.gradle.kts                |  7 +--
 sentry-async-profiler/build.gradle.kts        |  1 +
 sentry-graphql-22/build.gradle.kts            |  1 +
 sentry-graphql-core/build.gradle.kts          |  1 +
 sentry-graphql/build.gradle.kts               |  1 +
 sentry-jcache/build.gradle.kts                |  1 +
 sentry-jdbc/build.gradle.kts                  |  1 +
 sentry-jul/build.gradle.kts                   |  1 +
 sentry-kafka/build.gradle.kts                 |  1 +
 sentry-kotlin-extensions/build.gradle.kts     |  7 +--
 sentry-ktor-client/build.gradle.kts           |  7 +--
 sentry-launchdarkly-server/build.gradle.kts   |  1 +
 sentry-log4j2/build.gradle.kts                |  1 +
 sentry-logback/build.gradle.kts               |  1 +
 sentry-okhttp/build.gradle.kts                |  7 +--
 sentry-openfeature/build.gradle.kts           |  1 +
 sentry-openfeign/build.gradle.kts             |  1 +
 .../build.gradle.kts                          |  1 +
 .../build.gradle.kts                          |  1 +
 .../build.gradle.kts                          |  1 +
 .../build.gradle.kts                          |  1 +
 .../build.gradle.kts                          |  1 +
 .../build.gradle.kts                          |  1 +
 .../build.gradle.kts                          |  1 +
 .../build.gradle.kts                          |  1 +
 sentry-quartz/build.gradle.kts                |  1 +
 sentry-servlet-jakarta/build.gradle.kts       |  1 +
 sentry-servlet/build.gradle.kts               |  1 +
 sentry-spotlight/build.gradle.kts             |  7 +--
 sentry-spring-boot-starter/build.gradle.kts   |  1 +
 sentry-spring-boot/build.gradle.kts           |  1 +
 sentry-spring/build.gradle.kts                |  1 +
 sentry/build.gradle.kts                       | 20 ++-----
 39 files changed, 116 insertions(+), 58 deletions(-)
 create mode 100644 build-logic/src/main/kotlin/io/sentry/gradle/SentryAnimalSnifferPlugin.kt

diff --git a/build-logic/build.gradle.kts b/build-logic/build.gradle.kts
index 8abe9f55283..bba758f9b79 100644
--- a/build-logic/build.gradle.kts
+++ b/build-logic/build.gradle.kts
@@ -7,5 +7,19 @@ repositories {
 }
 
 dependencies {
+  implementation(libs.animalsniffer.gradle.plugin)
   implementation(libs.spotlessLib)
 }
+
+gradlePlugin {
+  plugins {
+    register("sentryAnimalSniffer") {
+      id = "io.sentry.animalsniffer"
+      implementationClass = "io.sentry.gradle.SentryAnimalSnifferPlugin"
+    }
+    register("sentryAnimalSnifferAndroid") {
+      id = "io.sentry.animalsniffer.android"
+      implementationClass = "io.sentry.gradle.SentryAnimalSnifferAndroidPlugin"
+    }
+  }
+}
diff --git a/build-logic/src/main/kotlin/io/sentry/gradle/SentryAnimalSnifferPlugin.kt b/build-logic/src/main/kotlin/io/sentry/gradle/SentryAnimalSnifferPlugin.kt
new file mode 100644
index 00000000000..f1bc2bafcf7
--- /dev/null
+++ b/build-logic/src/main/kotlin/io/sentry/gradle/SentryAnimalSnifferPlugin.kt
@@ -0,0 +1,57 @@
+package io.sentry.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.MinimalExternalModuleDependency
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.api.provider.ListProperty
+import ru.vyarus.gradle.plugin.animalsniffer.AnimalSniffer
+
+abstract class SentryAnimalSnifferExtension {
+  abstract val ignoredClasses: ListProperty<String>
+  abstract val excludedClasses: ListProperty<String>
+
+  fun ignoreClasses(vararg classes: String) {
+    ignoredClasses.addAll(*classes)
+  }
+
+  fun mainExcludes(vararg excludes: String) {
+    excludedClasses.addAll(*excludes)
+  }
+}
+
+class SentryAnimalSnifferPlugin : Plugin<Project> {
+  override fun apply(project: Project) {
+    project.pluginManager.apply("ru.vyarus.animalsniffer")
+
+    val extension =
+      project.extensions.create("sentryAnimalSniffer", SentryAnimalSnifferExtension::class.java)
+
+    project.addSignatureDependency("java8-signature")
+
+    project.tasks.named("animalsnifferMain", AnimalSniffer::class.java).configure {
+      ignoreClasses = ignoreClasses + extension.ignoredClasses.get()
+      exclude(extension.excludedClasses.get())
+    }
+
+    project.tasks.named("check").configure { dependsOn("animalsnifferMain") }
+  }
+}
+
+class SentryAnimalSnifferAndroidPlugin : Plugin<Project> {
+  override fun apply(project: Project) {
+    project.pluginManager.apply(SentryAnimalSnifferPlugin::class.java)
+
+    project.addSignatureDependency("gummy-bears-api21")
+  }
+}
+
+private fun Project.addSignatureDependency(libraryName: String) {
+  val libs = extensions.getByType(VersionCatalogsExtension::class.java).named("libs")
+  dependencies.add("signature", signatureNotation(libs.findLibrary(libraryName).get().get()))
+}
+
+private fun signatureNotation(dependency: MinimalExternalModuleDependency): String {
+  val module = "${dependency.module.group}:${dependency.module.name}"
+  return "$module:${dependency.versionConstraint.requiredVersion}@signature"
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 3a409707f3f..c2b473dbed5 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,4 +1,5 @@
 [versions]
+animalsniffer = "2.0.1"
 apollo = "2.5.9"
 androidxLifecycle = "2.2.0"
 androidxNavigation = "2.4.2"
@@ -11,6 +12,7 @@ coroutines = "1.6.1"
 espresso = "3.7.0"
 feign = "11.6"
 gummyBears = "0.12.0"
+java8Signature = "1.0"
 jackson = "2.18.3"
 jetbrainsCompose = "1.6.11"
 kotlin = "2.3.21"
@@ -70,11 +72,12 @@ springboot4 = { id = "org.springframework.boot", version.ref = "springboot4" }
 spring-dependency-management = { id = "io.spring.dependency-management", version = "1.1.7" }
 sqldelight = { id = "app.cash.sqldelight", version.ref = "sqldelight" }
 gretty = { id = "org.gretty", version = "4.0.0" }
-animalsniffer = { id = "ru.vyarus.animalsniffer", version = "2.0.1" }
+animalsniffer = { id = "ru.vyarus.animalsniffer", version.ref = "animalsniffer" }
 sentry = { id = "io.sentry.android.gradle", version.ref = "sagp"}
 shadow = { id = "com.gradleup.shadow", version = "9.4.1" }
 
 [libraries]
+animalsniffer-gradle-plugin = { module = "ru.vyarus:gradle-animalsniffer-plugin", version.ref = "animalsniffer" }
 apache-httpclient = { module = "org.apache.httpcomponents.client5:httpclient5", version = "5.0.4" }
 apollo2-coroutines = { module = "com.apollographql.apollo:apollo-coroutines-support", version.ref = "apollo" }
 apollo2-runtime = { module = "com.apollographql.apollo:apollo-runtime", version.ref = "apollo" }
@@ -226,6 +229,7 @@ timber = { module = "com.jakewharton.timber:timber", version = "4.7.1" }
 
 # Animalsniffer signature
 gummy-bears-api21 = { module = "com.toasttab.android:gummy-bears-api-21", version.ref = "gummyBears" }
+java8-signature = { module = "org.codehaus.mojo.signature:java18", version.ref = "java8Signature" }
 
 # tomcat libraries
 tomcat-catalina = { module = "org.apache.tomcat:tomcat-catalina", version = "9.0.108" }
diff --git a/sentry-apache-http-client-5/build.gradle.kts b/sentry-apache-http-client-5/build.gradle.kts
index 00916258b8f..984974bae9a 100644
--- a/sentry-apache-http-client-5/build.gradle.kts
+++ b/sentry-apache-http-client-5/build.gradle.kts
@@ -3,6 +3,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
   `java-library`
+  id("io.sentry.animalsniffer")
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.errorprone)
diff --git a/sentry-apollo-3/build.gradle.kts b/sentry-apollo-3/build.gradle.kts
index d70085e27bd..70f43d946ef 100644
--- a/sentry-apollo-3/build.gradle.kts
+++ b/sentry-apollo-3/build.gradle.kts
@@ -8,7 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
-  alias(libs.plugins.animalsniffer)
+  id("io.sentry.animalsniffer.android")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -37,13 +37,8 @@ dependencies {
   testImplementation(libs.mockito.kotlin)
   testImplementation(libs.mockito.inline)
   testImplementation(libs.okhttp.mockwebserver)
-
-  val gummyBearsModule = libs.gummy.bears.api21.get().module
-  signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-tasks { check { dependsOn(animalsnifferMain) } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-apollo-4/build.gradle.kts b/sentry-apollo-4/build.gradle.kts
index abb7ccb760e..4f1276f0bf4 100644
--- a/sentry-apollo-4/build.gradle.kts
+++ b/sentry-apollo-4/build.gradle.kts
@@ -8,7 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
-  alias(libs.plugins.animalsniffer)
+  id("io.sentry.animalsniffer.android")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -39,13 +39,8 @@ dependencies {
   testImplementation(libs.mockito.inline)
   testImplementation(libs.okhttp.mockwebserver)
   testImplementation("org.jetbrains.kotlin:kotlin-reflect:2.0.0")
-
-  val gummyBearsModule = libs.gummy.bears.api21.get().module
-  signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-tasks { check { dependsOn(animalsnifferMain) } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-apollo/build.gradle.kts b/sentry-apollo/build.gradle.kts
index 0fc853886df..2da8d8b20c1 100644
--- a/sentry-apollo/build.gradle.kts
+++ b/sentry-apollo/build.gradle.kts
@@ -8,7 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
-  alias(libs.plugins.animalsniffer)
+  id("io.sentry.animalsniffer.android")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -38,13 +38,8 @@ dependencies {
   testImplementation(libs.mockito.kotlin)
   testImplementation(libs.mockito.inline)
   testImplementation(libs.okhttp.mockwebserver)
-
-  val gummyBearsModule = libs.gummy.bears.api21.get().module
-  signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-tasks { check { dependsOn(animalsnifferMain) } }
-
 tasks.withType<JavaCompile>().configureEach {
   options.errorprone {
     check("NullAway", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
diff --git a/sentry-async-profiler/build.gradle.kts b/sentry-async-profiler/build.gradle.kts
index 17093fe6a09..17454baa662 100644
--- a/sentry-async-profiler/build.gradle.kts
+++ b/sentry-async-profiler/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-graphql-22/build.gradle.kts b/sentry-graphql-22/build.gradle.kts
index 3c0667fd0d4..32db28fae8f 100644
--- a/sentry-graphql-22/build.gradle.kts
+++ b/sentry-graphql-22/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-graphql-core/build.gradle.kts b/sentry-graphql-core/build.gradle.kts
index 62635ded34e..34f71ab9cfb 100644
--- a/sentry-graphql-core/build.gradle.kts
+++ b/sentry-graphql-core/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-graphql/build.gradle.kts b/sentry-graphql/build.gradle.kts
index 30000655079..d92dc52c6d7 100644
--- a/sentry-graphql/build.gradle.kts
+++ b/sentry-graphql/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-jcache/build.gradle.kts b/sentry-jcache/build.gradle.kts
index 1cc3b6e0e3d..b388f35881f 100644
--- a/sentry-jcache/build.gradle.kts
+++ b/sentry-jcache/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-jdbc/build.gradle.kts b/sentry-jdbc/build.gradle.kts
index 1e86048053e..e2a7f573138 100644
--- a/sentry-jdbc/build.gradle.kts
+++ b/sentry-jdbc/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-jul/build.gradle.kts b/sentry-jul/build.gradle.kts
index 66c46bcee21..2eec61eb171 100644
--- a/sentry-jul/build.gradle.kts
+++ b/sentry-jul/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-kafka/build.gradle.kts b/sentry-kafka/build.gradle.kts
index ef1ff252468..0d543bad270 100644
--- a/sentry-kafka/build.gradle.kts
+++ b/sentry-kafka/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-kotlin-extensions/build.gradle.kts b/sentry-kotlin-extensions/build.gradle.kts
index 8c4312641a8..101761b2a82 100644
--- a/sentry-kotlin-extensions/build.gradle.kts
+++ b/sentry-kotlin-extensions/build.gradle.kts
@@ -8,7 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.detekt)
-  alias(libs.plugins.animalsniffer)
+  id("io.sentry.animalsniffer.android")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -32,13 +32,8 @@ dependencies {
   testImplementation(libs.kotlinx.coroutines)
   testImplementation(libs.kotlinx.coroutines.test)
   testImplementation(libs.mockito.kotlin)
-
-  val gummyBearsModule = libs.gummy.bears.api21.get().module
-  signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-tasks { check { dependsOn(animalsnifferMain) } }
-
 tasks.withType<Detekt>().configureEach {
   // Target version of the generated JVM bytecode. It is used for type resolution.
   jvmTarget = JavaVersion.VERSION_1_8.toString()
diff --git a/sentry-ktor-client/build.gradle.kts b/sentry-ktor-client/build.gradle.kts
index 647563cc1d1..fefcdbfebaf 100644
--- a/sentry-ktor-client/build.gradle.kts
+++ b/sentry-ktor-client/build.gradle.kts
@@ -8,7 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
-  alias(libs.plugins.animalsniffer)
+  id("io.sentry.animalsniffer.android")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -39,13 +39,8 @@ dependencies {
   testImplementation(libs.ktor.client.core)
   testImplementation(libs.ktor.client.java)
   testImplementation(libs.okhttp.mockwebserver)
-
-  val gummyBearsModule = libs.gummy.bears.api21.get().module
-  signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-tasks { check { dependsOn(animalsnifferMain) } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.ktorClient")
diff --git a/sentry-launchdarkly-server/build.gradle.kts b/sentry-launchdarkly-server/build.gradle.kts
index 370252c2154..95aba9faaf5 100644
--- a/sentry-launchdarkly-server/build.gradle.kts
+++ b/sentry-launchdarkly-server/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-log4j2/build.gradle.kts b/sentry-log4j2/build.gradle.kts
index 1c5cf94e8eb..6e5250ece50 100644
--- a/sentry-log4j2/build.gradle.kts
+++ b/sentry-log4j2/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-logback/build.gradle.kts b/sentry-logback/build.gradle.kts
index 1c42a4e1c03..5fd6c975231 100644
--- a/sentry-logback/build.gradle.kts
+++ b/sentry-logback/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-okhttp/build.gradle.kts b/sentry-okhttp/build.gradle.kts
index d547720c174..47b8bfe5b15 100644
--- a/sentry-okhttp/build.gradle.kts
+++ b/sentry-okhttp/build.gradle.kts
@@ -8,7 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
-  alias(libs.plugins.animalsniffer)
+  id("io.sentry.animalsniffer.android")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -38,13 +38,8 @@ dependencies {
   testImplementation(libs.mockito.inline)
   testImplementation(libs.okhttp)
   testImplementation(libs.okhttp.mockwebserver)
-
-  val gummyBearsModule = libs.gummy.bears.api21.get().module
-  signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-tasks { check { dependsOn(animalsnifferMain) } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.okhttp")
diff --git a/sentry-openfeature/build.gradle.kts b/sentry-openfeature/build.gradle.kts
index fbabcb81aa5..b079ead1fc5 100644
--- a/sentry-openfeature/build.gradle.kts
+++ b/sentry-openfeature/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-openfeign/build.gradle.kts b/sentry-openfeign/build.gradle.kts
index 9b1ac2bbc29..3baa85dee26 100644
--- a/sentry-openfeign/build.gradle.kts
+++ b/sentry-openfeign/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-opentelemetry/sentry-opentelemetry-agent/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-agent/build.gradle.kts
index ef98d488bd1..054db790dc2 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-agent/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-agent/build.gradle.kts
@@ -2,6 +2,7 @@ import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 
 plugins {
   `java-library`
+  id("io.sentry.animalsniffer")
   id("io.sentry.javadoc")
   alias(libs.plugins.shadow)
 }
diff --git a/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts
index 71f31ce2afb..087568d03ee 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-agentcustomization/build.gradle.kts
@@ -3,6 +3,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
   `java-library`
+  id("io.sentry.animalsniffer")
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.errorprone)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-agentless-spring/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-agentless-spring/build.gradle.kts
index c02ca0ca468..5a94dcd4422 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-agentless-spring/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-agentless-spring/build.gradle.kts
@@ -2,6 +2,7 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 dependencies {
diff --git a/sentry-opentelemetry/sentry-opentelemetry-agentless/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-agentless/build.gradle.kts
index 43e87d53beb..72508d73737 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-agentless/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-agentless/build.gradle.kts
@@ -2,6 +2,7 @@ plugins {
   `java-library`
   id("io.sentry.javadoc")
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 dependencies {
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
index d4bd1af9ede..b69ae1be7b4 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
@@ -3,6 +3,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
   `java-library`
+  id("io.sentry.animalsniffer")
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.errorprone)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
index 91ec023e178..7c92b8a87a5 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
@@ -3,6 +3,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
   `java-library`
+  id("io.sentry.animalsniffer")
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.errorprone)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/build.gradle.kts
index 1ff16cd0a31..8a5093a6570 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp-spring/build.gradle.kts
@@ -1,5 +1,6 @@
 plugins {
   `java-library`
+  id("io.sentry.animalsniffer")
   id("io.sentry.javadoc")
 }
 
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
index d63c8a5c451..1792c852dc3 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
@@ -3,6 +3,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
   `java-library`
+  id("io.sentry.animalsniffer")
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.errorprone)
diff --git a/sentry-quartz/build.gradle.kts b/sentry-quartz/build.gradle.kts
index 6e227abafe6..f4f0d9d07d2 100644
--- a/sentry-quartz/build.gradle.kts
+++ b/sentry-quartz/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-servlet-jakarta/build.gradle.kts b/sentry-servlet-jakarta/build.gradle.kts
index 3cdc4772f18..5762a4ae52b 100644
--- a/sentry-servlet-jakarta/build.gradle.kts
+++ b/sentry-servlet-jakarta/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-servlet/build.gradle.kts b/sentry-servlet/build.gradle.kts
index 9f12d4ee177..c2e3fe8e52e 100644
--- a/sentry-servlet/build.gradle.kts
+++ b/sentry-servlet/build.gradle.kts
@@ -8,6 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-spotlight/build.gradle.kts b/sentry-spotlight/build.gradle.kts
index 71498aecd92..a8d538c2e2e 100644
--- a/sentry-spotlight/build.gradle.kts
+++ b/sentry-spotlight/build.gradle.kts
@@ -7,7 +7,7 @@ plugins {
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
-  alias(libs.plugins.animalsniffer)
+  id("io.sentry.animalsniffer.android")
   alias(libs.plugins.buildconfig)
 }
 
@@ -30,13 +30,8 @@ dependencies {
   testImplementation(libs.mockito.kotlin)
   testImplementation(libs.mockito.inline)
   testImplementation(projects.sentryTestSupport)
-
-  val gummyBearsModule = libs.gummy.bears.api21.get().module
-  signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
 }
 
-tasks { check { dependsOn(animalsnifferMain) } }
-
 buildConfig {
   useJavaOutput()
   packageName("io.sentry.spotlight")
diff --git a/sentry-spring-boot-starter/build.gradle.kts b/sentry-spring-boot-starter/build.gradle.kts
index f4da56179cb..cd05baecc4d 100644
--- a/sentry-spring-boot-starter/build.gradle.kts
+++ b/sentry-spring-boot-starter/build.gradle.kts
@@ -3,6 +3,7 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
   `java-library`
+  id("io.sentry.animalsniffer")
   id("io.sentry.javadoc")
   alias(libs.plugins.kotlin.jvm)
   alias(libs.plugins.errorprone)
diff --git a/sentry-spring-boot/build.gradle.kts b/sentry-spring-boot/build.gradle.kts
index 3ed6199fbc5..947eaf9b03a 100644
--- a/sentry-spring-boot/build.gradle.kts
+++ b/sentry-spring-boot/build.gradle.kts
@@ -9,6 +9,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry-spring/build.gradle.kts b/sentry-spring/build.gradle.kts
index fced2220f02..03176d7b867 100644
--- a/sentry-spring/build.gradle.kts
+++ b/sentry-spring/build.gradle.kts
@@ -9,6 +9,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
+  id("io.sentry.animalsniffer")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
diff --git a/sentry/build.gradle.kts b/sentry/build.gradle.kts
index 9717cb176ae..6b98ff790c6 100644
--- a/sentry/build.gradle.kts
+++ b/sentry/build.gradle.kts
@@ -8,7 +8,7 @@ plugins {
   alias(libs.plugins.errorprone)
   alias(libs.plugins.gradle.versions)
   alias(libs.plugins.buildconfig)
-  alias(libs.plugins.animalsniffer)
+  id("io.sentry.animalsniffer.android")
 }
 
 tasks.withType<KotlinCompile>().configureEach {
@@ -32,26 +32,16 @@ dependencies {
   testImplementation(libs.msgpack)
   testImplementation(libs.okio)
   testImplementation(projects.sentryTestSupport)
-
-  val gummyBearsModule = libs.gummy.bears.api21.get().module
-  signature("${gummyBearsModule}:${libs.versions.gummyBears.get()}@signature")
-}
-
-animalsniffer {
-  ignore =
-    listOf(
-      // We manually check on Android if it's available (API 26+).
-      "java.time.Instant"
-    )
 }
 
-tasks.animalsnifferMain {
+sentryAnimalSniffer {
+  // We manually check on Android if it's available (API 26+).
+  ignoreClasses("java.time.Instant")
   // Uses java.util.function.Supplier, but must be manually invoked.
-  exclude("**/io/sentry/SentryWrapper.class")
+  mainExcludes("**/io/sentry/SentryWrapper.class")
 }
 
 tasks {
-  check { dependsOn(animalsnifferMain) }
   test {
     // java.lang open is needed by tests that reflectively rewrite Class names; it was previously
     // provided implicitly by the jacoco test agent, which has been removed.

From dd1eb0c44c101686b71aed0a1732f2452646348c Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Tue, 14 Jul 2026 07:31:36 +0200
Subject: [PATCH 295/391] build: Bump Spotless to 8.8.0 (#5720)

* fix(spring): Support Spring Boot 4.1

Bump OpenTelemetry and Spring Boot dependencies to compatible versions so the Spring Boot 4 OpenTelemetry sample works with Spring Boot 4.1.

Keep the Spring 7 sample on the repository Kotlin compiler version when importing the Spring Boot BOM, and add Spring Boot 4.1 to the system test matrix.

Fixes GH-5561

Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

* build: Bump Kotlin to 2.3.21

Align the global Kotlin version with Spring Boot 4.1 and remove the now-unneeded Spring 7 BOM override.

Also remove unused Spring 7-specific Kotlin aliases from the version catalog.

Co-Authored-By: Claude <noreply@anthropic.com>

* build: Bump Spotless to 8.7.0

Update the Spotless Gradle plugin and apply the resulting formatting changes.

Co-Authored-By: Claude <noreply@anthropic.com>

* build: Bump Spotless to 8.8.0

Update the Spotless Gradle plugin to the latest available release.

Co-Authored-By: Claude <noreply@anthropic.com>

* Format code

* Apply suggestion from @adinauer

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 gradle/libs.versions.toml                     |   2 +-
 .../core/ActivityLifecycleIntegrationTest.kt  | 275 ++++++++----------
 .../core/AndroidContinuousProfilerTest.kt     |  11 +-
 .../core/AndroidLoggerBatchProcessorTest.kt   |  11 +-
 .../core/AndroidMetricsBatchProcessorTest.kt  |  11 +-
 .../ApplicationExitIntegrationTestBase.kt     |   6 +-
 .../sentry/android/core/SentryAndroidTest.kt  |   8 +-
 .../android/core/SentryLogcatAdapterTest.kt   |   9 +-
 .../core/SentryPerformanceProviderTest.kt     |   5 +-
 .../threaddump/ThreadDumpParserTest.kt        |  10 +-
 .../core/internal/util/CpuInfoUtilsTest.kt    |  15 +-
 .../io/sentry/uitest/android/ReplayTest.kt    |   9 +-
 .../uitest/android/UserInteractionTests.kt    |   9 +-
 .../java/io/sentry/android/replay/Windows.kt  |  13 +-
 .../replay/gestures/ReplayGestureConverter.kt |   9 +-
 .../replay/AnrWithReplayIntegrationTest.kt    |   9 +-
 .../DefaultReplayBreadcrumbConverterTest.kt   |   5 +-
 .../android/replay/ReplayIntegrationTest.kt   |   4 +-
 .../android/replay/ScreenshotRecorderTest.kt  |  14 +-
 .../ComposeMaskingOptionsTest.kt              |   7 +-
 .../sentry/android/timber/SentryTimberTree.kt |   5 +-
 ...yncProfilerToSentryProfileConverterTest.kt |  29 +-
 .../io/sentry/logback/SentryAppenderTest.kt   |   4 +-
 .../sentry/openfeign/SentryFeignClientTest.kt |  22 +-
 .../io/sentry/CheckInSerializationTest.kt     |  15 +-
 ...efaultCompositePerformanceCollectorTest.kt |   9 +-
 .../JsonReflectionObjectSerializerTest.kt     |   3 +-
 .../io/sentry/JsonUnknownSerializationTest.kt |   5 +-
 sentry/src/test/java/io/sentry/ScopeTest.kt   |  18 +-
 sentry/src/test/java/io/sentry/ScopesTest.kt  |  10 +-
 .../test/java/io/sentry/SentryClientTest.kt   | 261 +++++++++--------
 sentry/src/test/java/io/sentry/SentryTest.kt  |  28 +-
 .../test/java/io/sentry/SentryWrapperTest.kt  |  27 +-
 ...UncaughtExceptionHandlerIntegrationTest.kt |  17 +-
 .../ClientReportMultiThreadingTest.kt         |   7 +-
 .../transport/QueuedThreadPoolExecutorTest.kt |   9 +-
 36 files changed, 440 insertions(+), 471 deletions(-)

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index c2b473dbed5..1fd275d06f8 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -40,7 +40,7 @@ sagp = "6.13.0"
 sqlite = "2.6.2"
 sqliteRc = "2.7.0-rc01" # Required by Room3 3.0.0-rc*
 slf4j = "1.7.30"
-spotless = "8.6.0"
+spotless = "8.8.0"
 springboot2 = "2.7.18"
 springboot3 = "3.5.0"
 springboot4 = "4.1.0"
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
index d198c8d975e..1d8fa06f3bb 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
@@ -242,11 +242,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `Standalone app start transaction op is app start`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -257,8 +256,9 @@ class ActivityLifecycleIntegrationTest {
     verify(fixture.scopes, times(2)).startTransaction(any(), any<TransactionOptions>())
 
     val contexts = fixture.capturedContexts
-    val appStartContext =
-      contexts.single { it.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP }
+    val appStartContext = contexts.single {
+      it.operation == ActivityLifecycleIntegration.STANDALONE_APP_START_OP
+    }
     assertEquals("App Start", appStartContext.name)
     assertEquals(TransactionNameSource.COMPONENT, appStartContext.transactionNameSource)
     val appStartTransaction =
@@ -278,11 +278,10 @@ class ActivityLifecycleIntegrationTest {
   @Test
   @Config(sdk = [Build.VERSION_CODES.VANILLA_ICE_CREAM])
   fun `Standalone app start transaction carries app start reason when available`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -304,11 +303,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `Standalone app start transaction has no app start reason when unavailable`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -325,11 +323,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `extendAppStart eagerly creates a standalone app start transaction with the extended span`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -350,11 +347,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `extended app start continues the trace into ui load without a second app start transaction`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -381,11 +377,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `extended app start trace is not reused by a later activity`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -411,11 +406,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `extended app start screen is not overwritten by a later activity`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -436,11 +430,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `extended standalone app start transaction stays open until finishExtendedAppStart`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -463,11 +456,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `extended headless app start transaction stays open until finishExtendedAppStart`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     prepareHeadlessAppStart(appStartType = AppStartType.COLD)
@@ -489,11 +481,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `extended headless app start persists the app start end time`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     prepareHeadlessAppStart(appStartType = AppStartType.COLD)
@@ -506,11 +497,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `finished eager extended app start persists the app start end time`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -525,11 +515,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `activity long after the eager extended app start finished starts a fresh trace`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     // the eager extension starts at launch and finishes before any activity exists
@@ -557,11 +546,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `extended headless app start does not create a duplicate when the extension already finished`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     prepareHeadlessAppStart(appStartType = AppStartType.COLD)
@@ -590,11 +578,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `extended app start transaction is owned by the extension and survives activity destroy`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -611,11 +598,10 @@ class ActivityLifecycleIntegrationTest {
   @Test
   @Config(sdk = [Build.VERSION_CODES.VANILLA_ICE_CREAM])
   fun `Headless standalone app start transaction carries app start reason when available`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     prepareHeadlessAppStart(appStartType = AppStartType.COLD)
     val startInfo =
@@ -632,11 +618,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `HeadlessAppStartListener is registered when standalone flag is on and performance enabled`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     prepareHeadlessAppStart(appStartType = AppStartType.UNKNOWN)
 
@@ -674,11 +659,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `close clears HeadlessAppStartListener`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     sut.close()
     prepareHeadlessAppStart()
@@ -690,11 +674,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `onHeadlessAppStart creates standalone App Start transaction and stashes trace id`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     prepareHeadlessAppStart(appStartType = AppStartType.COLD)
 
@@ -721,11 +704,10 @@ class ActivityLifecycleIntegrationTest {
   @Test
   @Config(sdk = [Build.VERSION_CODES.M])
   fun `onHeadlessAppStart creates standalone App Start transaction on API 23`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     prepareHeadlessSdkInitAppStart()
 
@@ -748,11 +730,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `onHeadlessAppStart creates standalone App Start transaction when appStartType is WARM`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     prepareHeadlessAppStart(appStartType = AppStartType.WARM)
 
@@ -767,11 +748,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `onHeadlessAppStart does nothing when appStartTimeSpan is incomplete`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     AppStartMetrics.getInstance().appStartTimeSpan.reset()
     AppStartMetrics.getInstance().sdkInitTimeSpan.reset()
@@ -1086,11 +1066,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `When Activity is destroyed, sets standalone appStartTransaction status to cancelled and finish it`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     setAppStartTime()
@@ -1462,11 +1441,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `launcher activity emits ui load and standalone App Start sharing trace id`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     val firstFrameDate = SentryNanotimeDate(1499, 0)
     fixture.options.dateProvider = SentryDateProvider { firstFrameDate }
@@ -1517,11 +1495,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `launcher activity attaches lifecycle spans before finishing stopped standalone App Start`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     val appStartEndDate = SentryNanotimeDate(499, 0)
     setAppStartTime(SentryNanotimeDate(1, 0), appStartEndDate)
@@ -1550,11 +1527,10 @@ class ActivityLifecycleIntegrationTest {
   @Test
   fun `activity following a headless start reuses trace id and does not emit second standalone`() {
     val storedTraceId = SentryId()
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     AppStartMetrics.getInstance().setAppStartTraceId(storedTraceId)
     // headless start always stores the trace header alongside the trace id; the ui.load txn
     // continues that trace via continueTrace, sharing the trace id.
@@ -1576,11 +1552,10 @@ class ActivityLifecycleIntegrationTest {
   @Test
   fun `activity within a minute of the headless start continues the same trace`() {
     val storedTraceId = SentryId()
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     AppStartMetrics.getInstance().setAppStartTraceId(storedTraceId)
     AppStartMetrics.getInstance().appStartSentryTraceHeader =
       SentryTraceHeader(storedTraceId, SpanId(), true).value
@@ -1600,11 +1575,10 @@ class ActivityLifecycleIntegrationTest {
   @Test
   fun `activity more than a minute after the headless start starts a fresh trace`() {
     val storedTraceId = SentryId()
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     AppStartMetrics.getInstance().setAppStartTraceId(storedTraceId)
     AppStartMetrics.getInstance().appStartSentryTraceHeader =
       SentryTraceHeader(storedTraceId, SpanId(), true).value
@@ -1626,11 +1600,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `onHeadlessAppStart stores sentry-trace and baggage headers for continuation`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     prepareHeadlessAppStart(appStartType = AppStartType.COLD)
 
@@ -1648,11 +1621,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `launcher activity shares standalone App Start trace and sampleRand as a sibling`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
     setAppStartTime()
     // the app-start sampling decision carries the sampleRand the whole trace should share
@@ -1681,11 +1653,10 @@ class ActivityLifecycleIntegrationTest {
 
   @Test
   fun `activity following a headless start shares stored trace and sampleRand as a sibling and clears headers`() {
-    val sut =
-      fixture.getSut {
-        it.tracesSampleRate = 1.0
-        it.isEnableStandaloneAppStartTracing = true
-      }
+    val sut = fixture.getSut {
+      it.tracesSampleRate = 1.0
+      it.isEnableStandaloneAppStartTracing = true
+    }
     sut.register(fixture.scopes, fixture.options)
 
     // 1) a headless start emits the standalone app.start and stores its trace headers
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
index 162e56c36e3..8837030608e 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
@@ -539,13 +539,12 @@ class AndroidContinuousProfilerTest {
 
   @Test
   fun `profiler does not start when offline`() {
-    val profiler =
-      fixture.getSut {
-        it.connectionStatusProvider = mock { provider ->
-          whenever(provider.connectionStatus)
-            .thenReturn(IConnectionStatusProvider.ConnectionStatus.DISCONNECTED)
-        }
+    val profiler = fixture.getSut {
+      it.connectionStatusProvider = mock { provider ->
+        whenever(provider.connectionStatus)
+          .thenReturn(IConnectionStatusProvider.ConnectionStatus.DISCONNECTED)
       }
+    }
 
     // If the device is offline, the profiler should never start
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidLoggerBatchProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidLoggerBatchProcessorTest.kt
index ab83671fa0e..369f7f6a148 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidLoggerBatchProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidLoggerBatchProcessorTest.kt
@@ -68,12 +68,11 @@ class AndroidLoggerBatchProcessorTest {
 
   @Test
   fun `onBackground handles executor exception gracefully`() {
-    val sut =
-      fixture.getSut { options ->
-        val rejectingExecutor = mock<io.sentry.ISentryExecutorService>()
-        whenever(rejectingExecutor.submit(any())).thenThrow(RuntimeException("Rejected"))
-        options.executorService = rejectingExecutor
-      }
+    val sut = fixture.getSut { options ->
+      val rejectingExecutor = mock<io.sentry.ISentryExecutorService>()
+      whenever(rejectingExecutor.submit(any())).thenThrow(RuntimeException("Rejected"))
+      options.executorService = rejectingExecutor
+    }
 
     // Should not throw
     sut.onBackground()
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidMetricsBatchProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidMetricsBatchProcessorTest.kt
index fceb9ed3f4d..7d85502d149 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidMetricsBatchProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidMetricsBatchProcessorTest.kt
@@ -67,12 +67,11 @@ class AndroidMetricsBatchProcessorTest {
 
   @Test
   fun `onBackground handles executor exception gracefully`() {
-    val sut =
-      fixture.getSut { options ->
-        val rejectingExecutor = mock<io.sentry.ISentryExecutorService>()
-        whenever(rejectingExecutor.submit(any())).thenThrow(RuntimeException("Rejected"))
-        options.executorService = rejectingExecutor
-      }
+    val sut = fixture.getSut { options ->
+      val rejectingExecutor = mock<io.sentry.ISentryExecutorService>()
+      whenever(rejectingExecutor.submit(any())).thenThrow(RuntimeException("Rejected"))
+      options.executorService = rejectingExecutor
+    }
 
     // Should not throw
     sut.onBackground()
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitIntegrationTestBase.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitIntegrationTestBase.kt
index 649e14e413b..edb2ce1df24 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitIntegrationTestBase.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitIntegrationTestBase.kt
@@ -369,7 +369,11 @@ abstract class ApplicationExitIntegrationTestBase<THint : Any> {
     val hintAccessors: HintAccessors<THint>,
     val addExitInfo:
       ApplicationExitTestFixture<THint>.(
-        reason: Int?, timestamp: Long?, importance: Int?, addTrace: Boolean, addBadTrace: Boolean,
+        reason: Int?,
+        timestamp: Long?,
+        importance: Int?,
+        addTrace: Boolean,
+        addBadTrace: Boolean,
       ) -> Unit,
     val flushLogPrefix: String,
   )
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
index 8524a1cc807..2bd26051c07 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt
@@ -440,7 +440,9 @@ class SentryAndroidTest {
       // clean state for a new process.
       assertEquals(
         emptyList<Breadcrumb>(),
-        options.findPersistingScopeObserver()?.read(options, BREADCRUMBS_FILENAME, List::class.java),
+        options
+          .findPersistingScopeObserver()
+          ?.read(options, BREADCRUMBS_FILENAME, List::class.java),
       )
       assertEquals(
         SentryId.EMPTY_ID.toString(),
@@ -463,7 +465,9 @@ class SentryAndroidTest {
     // assert that persisted values have changed
     assertEquals(
       "TestActivity",
-      options.findPersistingScopeObserver()?.read(options, TRANSACTION_FILENAME, String::class.java),
+      options
+        .findPersistingScopeObserver()
+        ?.read(options, TRANSACTION_FILENAME, String::class.java),
     )
     assertEquals(
       "io.sentry.sample@1.1.0+220",
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryLogcatAdapterTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryLogcatAdapterTest.kt
index 1a84a1282da..0c0c03d71d2 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryLogcatAdapterTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryLogcatAdapterTest.kt
@@ -31,11 +31,10 @@ class SentryLogcatAdapterTest {
         Bundle().apply { putString(ManifestMetadataReader.DSN, "https://key@sentry.io/123") }
       val mockContext = ContextUtilsTestHelper.mockMetaData(metaData = metadata)
       initForTest(mockContext) {
-        it.beforeBreadcrumb =
-          SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
-            breadcrumbs.add(breadcrumb)
-            breadcrumb
-          }
+        it.beforeBreadcrumb = SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
+          breadcrumbs.add(breadcrumb)
+          breadcrumb
+        }
         it.logs.isEnabled = true
         it.logs.beforeSend =
           SentryOptions.Logs.BeforeSendLogCallback { logEvent ->
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt
index 58dc56d1493..254571181a6 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt
@@ -257,8 +257,9 @@ class SentryPerformanceProviderTest {
 
   @Test
   fun `when provider is closed, profiler is stopped`() {
-    val provider =
-      fixture.getSut { config -> writeConfig(config, continuousProfilingEnabled = false) }
+    val provider = fixture.getSut { config ->
+      writeConfig(config, continuousProfilingEnabled = false)
+    }
     provider.shutdown()
     assertNotNull(AppStartMetrics.getInstance().appStartProfiler)
     assertFalse(AppStartMetrics.getInstance().appStartProfiler!!.isRunning)
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt
index ec5dbd58902..c5798be2111 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/threaddump/ThreadDumpParserTest.kt
@@ -52,8 +52,9 @@ class ThreadDumpParserTest {
     assertEquals(SentryLockReason.SLEEPING, blockingThread.heldLocks!!["0x09228c2d"]!!.type)
     assertEquals(null, blockingThread.heldLocks!!["0x09228c2d"]!!.threadId)
 
-    val randomThread =
-      threads.find { it.name == "io.sentry.android.core.internal.util.SentryFrameMetricsCollector" }
+    val randomThread = threads.find {
+      it.name == "io.sentry.android.core.internal.util.SentryFrameMetricsCollector"
+    }
     assertEquals(19, randomThread!!.id)
     assertEquals("Native", randomThread.state)
     assertEquals(false, randomThread.isCrashed)
@@ -155,8 +156,9 @@ class ThreadDumpParserTest {
     assertNull(deletedFrame.addrMode)
 
     val debugImages = parser.debugImages
-    val image =
-      debugImages.first { image -> image.debugId == "499d48ba-c085-17cf-3209-da67405662f9" }
+    val image = debugImages.first { image ->
+      image.debugId == "499d48ba-c085-17cf-3209-da67405662f9"
+    }
     assertNotNull(image)
     assertEquals("499d48ba-c085-17cf-3209-da67405662f9", image.debugId)
     assertEquals("/apex/com.android.runtime/lib64/bionic/libc.so", image.codeFile)
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/CpuInfoUtilsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/CpuInfoUtilsTest.kt
index a6611e17e9a..c3993b94efd 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/CpuInfoUtilsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/CpuInfoUtilsTest.kt
@@ -14,14 +14,13 @@ class CpuInfoUtilsTest {
   private lateinit var cpuDirs: File
   private lateinit var ciu: CpuInfoUtils
 
-  private fun populateCpuFiles(values: List<String>) =
-    values.mapIndexed { i, v ->
-      val cpuMaxFreqFile =
-        File(cpuDirs, "cpu$i${File.separator}${CpuInfoUtils.CPUINFO_MAX_FREQ_PATH}")
-      cpuMaxFreqFile.parentFile?.mkdirs()
-      cpuMaxFreqFile.writeText(v)
-      cpuMaxFreqFile
-    }
+  private fun populateCpuFiles(values: List<String>) = values.mapIndexed { i, v ->
+    val cpuMaxFreqFile =
+      File(cpuDirs, "cpu$i${File.separator}${CpuInfoUtils.CPUINFO_MAX_FREQ_PATH}")
+    cpuMaxFreqFile.parentFile?.mkdirs()
+    cpuMaxFreqFile.writeText(v)
+    cpuMaxFreqFile
+  }
 
   @BeforeTest
   fun `set up`() {
diff --git a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt
index 3827561e37c..9c53f0a022d 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt
@@ -70,11 +70,10 @@ class ReplayTest : BaseUiTest() {
     initSentry {
       it.sessionReplay.sessionSampleRate = 1.0
 
-      it.beforeSendReplay =
-        SentryOptions.BeforeSendReplayCallback { event, _ ->
-          sent.set(true)
-          event
-        }
+      it.beforeSendReplay = SentryOptions.BeforeSendReplayCallback { event, _ ->
+        sent.set(true)
+        event
+      }
     }
 
     // wait until first segment is being sent
diff --git a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/UserInteractionTests.kt b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/UserInteractionTests.kt
index b76017aeb0b..2ea1905b761 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/UserInteractionTests.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/UserInteractionTests.kt
@@ -89,11 +89,10 @@ class UserInteractionTests : BaseUiTest() {
       options.profilesSampleRate = 1.0
       options.isEnableUserInteractionTracing = true
       options.isEnableUserInteractionBreadcrumbs = true
-      options.beforeBreadcrumb =
-        SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
-          breadcrumbs.add(breadcrumb)
-          breadcrumb
-        }
+      options.beforeBreadcrumb = SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
+        breadcrumbs.add(breadcrumb)
+        breadcrumb
+      }
     }
   }
 }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/Windows.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/Windows.kt
index 9b9d8f0157b..e81c815dc11 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/Windows.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/Windows.kt
@@ -83,14 +83,13 @@ internal object WindowSpy {
       }
     }
 
-  fun pullWindow(maybeDecorView: View): Window? =
-    decorViewClass?.let { decorViewClass ->
-      if (decorViewClass.isInstance(maybeDecorView)) {
-        windowField?.let { windowField -> windowField[maybeDecorView] as Window }
-      } else {
-        null
-      }
+  fun pullWindow(maybeDecorView: View): Window? = decorViewClass?.let { decorViewClass ->
+    if (decorViewClass.isInstance(maybeDecorView)) {
+      windowField?.let { windowField -> windowField[maybeDecorView] as Window }
+    } else {
+      null
     }
+  }
 }
 
 /**
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/gestures/ReplayGestureConverter.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/gestures/ReplayGestureConverter.kt
index 70d0988d3b0..cbedfc24cc2 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/gestures/ReplayGestureConverter.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/gestures/ReplayGestureConverter.kt
@@ -65,11 +65,10 @@ internal class ReplayGestureConverter(private val dateProvider: ICurrentDateProv
               moveEvents +=
                 RRWebInteractionMoveEvent().apply {
                   this.timestamp = now
-                  this.positions =
-                    positions.map { pos ->
-                      pos.timeOffset -= totalOffset
-                      pos
-                    }
+                  this.positions = positions.map { pos ->
+                    pos.timeOffset -= totalOffset
+                    pos
+                  }
                   this.pointerId = pointerId
                 }
               currentPositions[pointerId]!!.clear()
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/AnrWithReplayIntegrationTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/AnrWithReplayIntegrationTest.kt
index 1214c55c057..3df08b2af24 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/AnrWithReplayIntegrationTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/AnrWithReplayIntegrationTest.kt
@@ -155,11 +155,10 @@ class AnrWithReplayIntegrationTest {
       it.sessionReplay.onErrorSampleRate = 1.0
       // beforeSend is called after event processors are applied, so we can assert here
       // against the enriched ANR event
-      it.beforeSend =
-        SentryOptions.BeforeSendCallback { event, _ ->
-          assertEquals(replayId2.toString(), event.contexts[Contexts.REPLAY_ID])
-          event
-        }
+      it.beforeSend = SentryOptions.BeforeSendCallback { event, _ ->
+        assertEquals(replayId2.toString(), event.contexts[Contexts.REPLAY_ID])
+        event
+      }
       it.addEventProcessor(
         object : EventProcessor {
           override fun process(event: SentryReplayEvent, hint: Hint): SentryReplayEvent {
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
index 3da118190f0..749d3496698 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/DefaultReplayBreadcrumbConverterTest.kt
@@ -368,8 +368,9 @@ class DefaultReplayBreadcrumbConverterTest {
       }
 
     // Set up options with a user callback that returns modified breadcrumb
-    val userBeforeBreadcrumbCallback =
-      SentryOptions.BeforeBreadcrumbCallback { _, _ -> userModifiedBreadcrumb }
+    val userBeforeBreadcrumbCallback = SentryOptions.BeforeBreadcrumbCallback { _, _ ->
+      userModifiedBreadcrumb
+    }
     val options = SentryOptions.empty()
     options.beforeBreadcrumb = userBeforeBreadcrumbCallback
 
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
index 61b5213e76f..32b7f4e9285 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayIntegrationTest.kt
@@ -1043,7 +1043,9 @@ class ReplayIntegrationTest {
     replay.start()
 
     fixture.options.sessionReplay.frameObserver =
-      SentryReplayOptions.ReplayFrameObserver { _, _, _ -> throw RuntimeException("test") }
+      SentryReplayOptions.ReplayFrameObserver { _, _, _ ->
+        throw RuntimeException("test")
+      }
 
     val sourceBitmap =
       mock<Bitmap> {
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ScreenshotRecorderTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ScreenshotRecorderTest.kt
index 0a5c73f8a5c..2818eeb3537 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ScreenshotRecorderTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ScreenshotRecorderTest.kt
@@ -42,10 +42,9 @@ class ScreenshotRecorderTest {
 
   @Test
   fun `when config uses PIXEL_COPY strategy, ScreenshotRecorder creates PixelCopyStrategy`() {
-    val recorder =
-      fixture.getSut { options ->
-        options.sessionReplay.screenshotStrategy = ScreenshotStrategyType.PIXEL_COPY
-      }
+    val recorder = fixture.getSut { options ->
+      options.sessionReplay.screenshotStrategy = ScreenshotStrategyType.PIXEL_COPY
+    }
 
     val strategy = getStrategy(recorder)
 
@@ -57,10 +56,9 @@ class ScreenshotRecorderTest {
 
   @Test
   fun `when config uses CANVAS strategy, ScreenshotRecorder creates CanvasStrategy`() {
-    val recorder =
-      fixture.getSut { options ->
-        options.sessionReplay.screenshotStrategy = ScreenshotStrategyType.CANVAS
-      }
+    val recorder = fixture.getSut { options ->
+      options.sessionReplay.screenshotStrategy = ScreenshotStrategyType.CANVAS
+    }
     val strategy = getStrategy(recorder)
 
     assertTrue(
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
index baf0a32a415..0accb9ed16d 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/ComposeMaskingOptionsTest.kt
@@ -233,10 +233,9 @@ class ComposeMaskingOptionsTest {
     val textNodes = activity.get().collectNodesOfType<TextViewHierarchyNode>(options)
     assertEquals(4, textNodes.size) // [TextField, Text, Button, Activity Title]
 
-    val unmaskNode =
-      textNodes.first {
-        (it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text == "Make Request"
-      }
+    val unmaskNode = textNodes.first {
+      (it.layout as? ComposeTextLayout)?.layout?.layoutInput?.text?.text == "Make Request"
+    }
     assertTrue(unmaskNode.isVisible, "The unmasked node must be visible for the test to be valid")
     assertFalse(unmaskNode.shouldMask, "Node with sentryReplayUnmask() should not be masked")
 
diff --git a/sentry-android-timber/src/main/java/io/sentry/android/timber/SentryTimberTree.kt b/sentry-android-timber/src/main/java/io/sentry/android/timber/SentryTimberTree.kt
index 9c87c8a461d..61b1f99fb16 100644
--- a/sentry-android-timber/src/main/java/io/sentry/android/timber/SentryTimberTree.kt
+++ b/sentry-android-timber/src/main/java/io/sentry/android/timber/SentryTimberTree.kt
@@ -248,8 +248,9 @@ public class SentryTimberTree(
   ) {
     // checks the log level
     if (isLoggable(sentryLogLevel, minLogLevel)) {
-      val attributes =
-        tag?.let { SentryAttributes.of(SentryAttribute.stringAttribute("timber.tag", tag)) }
+      val attributes = tag?.let {
+        SentryAttributes.of(SentryAttribute.stringAttribute("timber.tag", tag))
+      }
       val params = SentryLogParameters.create(attributes)
       params.origin = "auto.log.timber"
 
diff --git a/sentry-async-profiler/src/test/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverterTest.kt b/sentry-async-profiler/src/test/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverterTest.kt
index d565fd9d51d..26a10352176 100644
--- a/sentry-async-profiler/src/test/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverterTest.kt
+++ b/sentry-async-profiler/src/test/java/io/sentry/asyncprofiler/convert/JfrAsyncProfilerToSentryProfileConverterTest.kt
@@ -218,13 +218,12 @@ class JfrAsyncProfilerToSentryProfileConverterTest {
     assertTrue(frames.isNotEmpty())
 
     // Find frames with complete information
-    val completeFrames =
-      frames.filter { frame ->
-        frame.function != null &&
-          frame.module != null &&
-          frame.lineno != null &&
-          frame.filename != null
-      }
+    val completeFrames = frames.filter { frame ->
+      frame.function != null &&
+        frame.module != null &&
+        frame.lineno != null &&
+        frame.filename != null
+    }
 
     assertTrue(completeFrames.isNotEmpty(), "Should have frames with complete information")
   }
@@ -238,15 +237,15 @@ class JfrAsyncProfilerToSentryProfileConverterTest {
     val frames = sentryProfile.frames
 
     // Verify system packages are marked as not in-app
-    val systemFrames =
-      frames.filter { frame ->
-        frame.module?.let {
-          it.startsWith("java.") || it.startsWith("sun.") || it.startsWith("jdk.")
-        } ?: false
-      }
+    val systemFrames = frames.filter { frame ->
+      frame.module?.let {
+        it.startsWith("java.") || it.startsWith("sun.") || it.startsWith("jdk.")
+      } ?: false
+    }
 
-    val inappSentryFrames =
-      frames.filter { frame -> frame.module?.startsWith("io.sentry.") ?: false }
+    val inappSentryFrames = frames.filter { frame ->
+      frame.module?.startsWith("io.sentry.") ?: false
+    }
 
     val emptyModuleFrames = frames.filter { it.module.isNullOrEmpty() }
 
diff --git a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
index e93d6ef2db1..877d2a23d75 100644
--- a/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
+++ b/sentry-logback/src/test/kotlin/io/sentry/logback/SentryAppenderTest.kt
@@ -121,7 +121,9 @@ class SentryAppenderTest {
       Fixture(
         startLater = true,
         options =
-          SentryOptions().also { it.setTag("only-present-if-logger-init-was-run", "another-value") },
+          SentryOptions().also {
+            it.setTag("only-present-if-logger-init-was-run", "another-value")
+          },
       )
     initForTest {
       it.dsn = "http://key@localhost/proj"
diff --git a/sentry-openfeign/src/test/kotlin/io/sentry/openfeign/SentryFeignClientTest.kt b/sentry-openfeign/src/test/kotlin/io/sentry/openfeign/SentryFeignClientTest.kt
index 571a2339326..c25a81f9501 100644
--- a/sentry-openfeign/src/test/kotlin/io/sentry/openfeign/SentryFeignClientTest.kt
+++ b/sentry-openfeign/src/test/kotlin/io/sentry/openfeign/SentryFeignClientTest.kt
@@ -286,11 +286,10 @@ class SentryFeignClientTest {
 
   @Test
   fun `customizer modifies span`() {
-    val sut =
-      fixture.getSut { span, _, _ ->
-        span.description = "overwritten description"
-        span
-      }
+    val sut = fixture.getSut { span, _, _ ->
+      span.description = "overwritten description"
+      span
+    }
     sut.getOk()
     assertEquals(1, fixture.sentryTracer.children.size)
     val httpClientSpan = fixture.sentryTracer.children.first()
@@ -299,13 +298,12 @@ class SentryFeignClientTest {
 
   @Test
   fun `customizer receives request and response`() {
-    val sut =
-      fixture.getSut { span, request, response ->
-        assertEquals(request.url(), request.url())
-        assertEquals(request.httpMethod().name, request.httpMethod().name)
-        assertNotNull(response) { assertEquals(201, it.status()) }
-        span
-      }
+    val sut = fixture.getSut { span, request, response ->
+      assertEquals(request.url(), request.url())
+      assertEquals(request.httpMethod().name, request.httpMethod().name)
+      assertNotNull(response) { assertEquals(201, it.status()) }
+      span
+    }
     sut.getOk()
   }
 
diff --git a/sentry/src/test/java/io/sentry/CheckInSerializationTest.kt b/sentry/src/test/java/io/sentry/CheckInSerializationTest.kt
index 51d37764f4d..69c65a64c62 100644
--- a/sentry/src/test/java/io/sentry/CheckInSerializationTest.kt
+++ b/sentry/src/test/java/io/sentry/CheckInSerializationTest.kt
@@ -42,14 +42,13 @@ class CheckInSerializationTest {
           } else {
             MonitorConfig(MonitorSchedule.interval(42, MonitorScheduleUnit.MINUTE))
           }
-        monitorConfig =
-          monitorConfigTmp.apply {
-            checkinMargin = 8L
-            maxRuntime = 9L
-            timezone = ZoneId.of("Europe/Vienna").id
-            failureIssueThreshold = 10
-            recoveryThreshold = 20
-          }
+        monitorConfig = monitorConfigTmp.apply {
+          checkinMargin = 8L
+          maxRuntime = 9L
+          timezone = ZoneId.of("Europe/Vienna").id
+          failureIssueThreshold = 10
+          recoveryThreshold = 20
+        }
       }
   }
 
diff --git a/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt b/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
index f8e3a8f9f98..bd1e584c2d7 100644
--- a/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
+++ b/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
@@ -191,11 +191,10 @@ class DefaultCompositePerformanceCollectorTest {
         SentryNanotimeDate(TimeUnit.SECONDS.toMillis(131), TimeUnit.SECONDS.toNanos(131)),
       )
     whenever(mockDateProvider.now()).thenReturn(dates[0], dates[0], dates[0], dates[1])
-    val collector =
-      fixture.getSut {
-        it.dateProvider = mockDateProvider
-        it.addPerformanceCollector(mockCollector)
-      }
+    val collector = fixture.getSut {
+      it.dateProvider = mockDateProvider
+      it.addPerformanceCollector(mockCollector)
+    }
     collector.start(fixture.transaction1)
     verify(fixture.mockTimer, never())!!.cancel()
 
diff --git a/sentry/src/test/java/io/sentry/JsonReflectionObjectSerializerTest.kt b/sentry/src/test/java/io/sentry/JsonReflectionObjectSerializerTest.kt
index 3ef48dad5ef..bd1de8fcbc7 100644
--- a/sentry/src/test/java/io/sentry/JsonReflectionObjectSerializerTest.kt
+++ b/sentry/src/test/java/io/sentry/JsonReflectionObjectSerializerTest.kt
@@ -102,7 +102,8 @@ class JsonReflectionObjectSerializerTest {
         "child" to
           mapOf<String, Any?>(
             "title" to "First Child",
-            "child" to mapOf<String, Any?>("title" to "Second Child", "child" to "fixture-toString"),
+            "child" to
+              mapOf<String, Any?>("title" to "Second Child", "child" to "fixture-toString"),
           ),
       )
     val actual = fixture.getSut().serialize(root, fixture.logger)
diff --git a/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt b/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt
index 438d20a9c44..37bf1efef98 100644
--- a/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt
+++ b/sentry/src/test/java/io/sentry/JsonUnknownSerializationTest.kt
@@ -145,8 +145,9 @@ class JsonUnknownSerializationTest(
       )
     }
 
-    private fun <T : JsonUnknown> givenJsonUnknown(jsonUnknown: T): T =
-      jsonUnknown.apply { unknown = mapOf("fixture-key" to "fixture-value") }
+    private fun <T : JsonUnknown> givenJsonUnknown(jsonUnknown: T): T = jsonUnknown.apply {
+      unknown = mapOf("fixture-key" to "fixture-value")
+    }
   }
 
   @Test
diff --git a/sentry/src/test/java/io/sentry/ScopeTest.kt b/sentry/src/test/java/io/sentry/ScopeTest.kt
index 4b0047fdc18..86aaf6f8f24 100644
--- a/sentry/src/test/java/io/sentry/ScopeTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopeTest.kt
@@ -359,11 +359,10 @@ class ScopeTest {
     val options =
       SentryOptions().apply {
         maxBreadcrumbs = 0
-        beforeBreadcrumb =
-          SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
-            called = true
-            breadcrumb
-          }
+        beforeBreadcrumb = SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
+          called = true
+          breadcrumb
+        }
       }
 
     val scope = Scope(options)
@@ -377,11 +376,10 @@ class ScopeTest {
     var called = false
     val options =
       SentryOptions().apply {
-        beforeBreadcrumb =
-          SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
-            called = true
-            breadcrumb
-          }
+        beforeBreadcrumb = SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
+          called = true
+          breadcrumb
+        }
       }
 
     val scope = Scope(options)
diff --git a/sentry/src/test/java/io/sentry/ScopesTest.kt b/sentry/src/test/java/io/sentry/ScopesTest.kt
index a4c2c76845e..4b9b3095d53 100644
--- a/sentry/src/test/java/io/sentry/ScopesTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopesTest.kt
@@ -187,8 +187,9 @@ class ScopesTest {
   fun `when beforeBreadcrumb returns null, crumb is dropped`() {
     val options = SentryOptions()
     options.cacheDirPath = file.absolutePath
-    options.beforeBreadcrumb =
-      SentryOptions.BeforeBreadcrumbCallback { _: Breadcrumb, _: Any? -> null }
+    options.beforeBreadcrumb = SentryOptions.BeforeBreadcrumbCallback { _: Breadcrumb, _: Any? ->
+      null
+    }
     options.dsn = "https://key@sentry.io/proj"
     options.setSerializer(mock())
     val sut = createScopes(options)
@@ -240,8 +241,9 @@ class ScopesTest {
 
     val options = SentryOptions()
     options.cacheDirPath = file.absolutePath
-    options.beforeBreadcrumb =
-      SentryOptions.BeforeBreadcrumbCallback { _: Breadcrumb, _: Any? -> throw exception }
+    options.beforeBreadcrumb = SentryOptions.BeforeBreadcrumbCallback { _: Breadcrumb, _: Any? ->
+      throw exception
+    }
     options.dsn = "https://key@sentry.io/proj"
     options.setSerializer(mock())
     val sut = createScopes(options)
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index f9cf7de567c..fff05933d4e 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -424,7 +424,11 @@ class SentryClientTest {
       fixture.sentryOptions.clientReportRecorder,
       listOf(
         DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetric.category, 1),
-        DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetricByte.category, 120),
+        DiscardedEvent(
+          DiscardReason.BEFORE_SEND.reason,
+          DataCategory.TraceMetricByte.category,
+          120,
+        ),
       ),
     )
   }
@@ -447,7 +451,11 @@ class SentryClientTest {
       fixture.sentryOptions.clientReportRecorder,
       listOf(
         DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetric.category, 1),
-        DiscardedEvent(DiscardReason.BEFORE_SEND.reason, DataCategory.TraceMetricByte.category, 120),
+        DiscardedEvent(
+          DiscardReason.BEFORE_SEND.reason,
+          DataCategory.TraceMetricByte.category,
+          120,
+        ),
       ),
     )
   }
@@ -2341,10 +2349,9 @@ class SentryClientTest {
 
   @Test
   fun `dropping a captured error from beforeSend has no effect on session and does not send anything`() {
-    val sut =
-      fixture.getSut { options ->
-        options.beforeSend = SentryOptions.BeforeSendCallback { _, _ -> null }
-      }
+    val sut = fixture.getSut { options ->
+      options.beforeSend = SentryOptions.BeforeSendCallback { _, _ -> null }
+    }
     val scope = givenScopeWithStartedSession()
 
     sut.captureEvent(SentryEvent().apply { exceptions = createHandledException() }, scope)
@@ -2355,8 +2362,9 @@ class SentryClientTest {
 
   @Test
   fun `dropping a captured error from eventProcessor has no effect on session and does not send anything`() {
-    val sut =
-      fixture.getSut { options -> options.addEventProcessor(DropEverythingEventProcessor()) }
+    val sut = fixture.getSut { options ->
+      options.addEventProcessor(DropEverythingEventProcessor())
+    }
     val scope = givenScopeWithStartedSession()
 
     sut.captureEvent(SentryEvent().apply { exceptions = createHandledException() }, scope)
@@ -2444,13 +2452,12 @@ class SentryClientTest {
 
     fixture.sentryOptions.onDiscard = onDiscardMock
 
-    val sut =
-      fixture.getSut { options ->
-        options.sampleRate = 0.000000000001
-        options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
-        options.beforeSend = beforeSendMock
-        options.addEventProcessor(globalEventProcessorMock)
-      }
+    val sut = fixture.getSut { options ->
+      options.sampleRate = 0.000000000001
+      options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
+      options.beforeSend = beforeSendMock
+      options.addEventProcessor(globalEventProcessorMock)
+    }
     val scope = givenScopeWithStartedSession()
     scope.addEventProcessor(scopedEventProcessorMock)
 
@@ -2487,13 +2494,12 @@ class SentryClientTest {
       it.arguments.first() as SentryEvent
     }
 
-    val sut =
-      fixture.getSut { options ->
-        options.sampleRate = 0.000000000001
-        options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
-        options.beforeSend = beforeSendMock
-        options.addEventProcessor(globalEventProcessorMock)
-      }
+    val sut = fixture.getSut { options ->
+      options.sampleRate = 0.000000000001
+      options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
+      options.beforeSend = beforeSendMock
+      options.addEventProcessor(globalEventProcessorMock)
+    }
     val scope = givenScopeWithStartedSession()
     scope.addEventProcessor(scopedEventProcessorMock)
 
@@ -2530,13 +2536,12 @@ class SentryClientTest {
     }
     whenever(beforeSendMock.execute(any(), anyOrNull())).thenReturn(null)
 
-    val sut =
-      fixture.getSut { options ->
-        options.sampleRate = 0.000000000001
-        options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
-        options.beforeSend = beforeSendMock
-        options.addEventProcessor(globalEventProcessorMock)
-      }
+    val sut = fixture.getSut { options ->
+      options.sampleRate = 0.000000000001
+      options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
+      options.beforeSend = beforeSendMock
+      options.addEventProcessor(globalEventProcessorMock)
+    }
     val scope = givenScopeWithStartedSession()
     scope.addEventProcessor(scopedEventProcessorMock)
 
@@ -2569,13 +2574,12 @@ class SentryClientTest {
     whenever(globalEventProcessorMock.process(any<SentryEvent>(), anyOrNull())).thenReturn(null)
     whenever(beforeSendMock.execute(any(), anyOrNull())).thenReturn(null)
 
-    val sut =
-      fixture.getSut { options ->
-        options.sampleRate = 0.000000000001
-        options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
-        options.beforeSend = beforeSendMock
-        options.addEventProcessor(globalEventProcessorMock)
-      }
+    val sut = fixture.getSut { options ->
+      options.sampleRate = 0.000000000001
+      options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
+      options.beforeSend = beforeSendMock
+      options.addEventProcessor(globalEventProcessorMock)
+    }
     val scope = givenScopeWithStartedSession()
     scope.addEventProcessor(scopedEventProcessorMock)
 
@@ -2610,13 +2614,12 @@ class SentryClientTest {
     whenever(globalEventProcessorMock.process(any<SentryEvent>(), anyOrNull())).thenReturn(null)
     whenever(beforeSendMock.execute(any(), anyOrNull())).thenReturn(null)
 
-    val sut =
-      fixture.getSut { options ->
-        options.sampleRate = 0.000000000001
-        options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
-        options.beforeSend = beforeSendMock
-        options.addEventProcessor(globalEventProcessorMock)
-      }
+    val sut = fixture.getSut { options ->
+      options.sampleRate = 0.000000000001
+      options.addIgnoredExceptionForType(NegativeArraySizeException::class.java)
+      options.beforeSend = beforeSendMock
+      options.addEventProcessor(globalEventProcessorMock)
+    }
     val scope = givenScopeWithStartedSession()
     scope.addEventProcessor(scopedEventProcessorMock)
 
@@ -2658,14 +2661,13 @@ class SentryClientTest {
 
   @Test
   fun `can add to attachments in beforeSend`() {
-    val sut =
-      fixture.getSut { options ->
-        options.setBeforeSend { event, hints ->
-          assertEquals(listOf(fixture.attachment, fixture.attachment2), hints.attachments)
-          hints.addAttachment(fixture.attachment3)
-          event
-        }
+    val sut = fixture.getSut { options ->
+      options.setBeforeSend { event, hints ->
+        assertEquals(listOf(fixture.attachment, fixture.attachment2), hints.attachments)
+        hints.addAttachment(fixture.attachment3)
+        event
       }
+    }
 
     val scope = givenScopeWithStartedSession()
     scope.addAttachment(fixture.attachment2)
@@ -2676,13 +2678,12 @@ class SentryClientTest {
 
   @Test
   fun `can replace attachments in beforeSend`() {
-    val sut =
-      fixture.getSut { options ->
-        options.setBeforeSend { event, hints ->
-          hints.replaceAttachments(listOf(fixture.attachment3))
-          event
-        }
+    val sut = fixture.getSut { options ->
+      options.setBeforeSend { event, hints ->
+        hints.replaceAttachments(listOf(fixture.attachment3))
+        event
       }
+    }
 
     val scope = givenScopeWithStartedSession()
     scope.addAttachment(fixture.attachment2)
@@ -2693,22 +2694,21 @@ class SentryClientTest {
 
   @Test
   fun `can add to attachments in eventProcessor`() {
-    val sut =
-      fixture.getSut { options ->
-        options.addEventProcessor(
-          object : EventProcessor {
-            override fun process(event: SentryEvent, hint: Hint): SentryEvent? {
-              assertEquals(listOf(fixture.attachment, fixture.attachment2), hint.attachments)
-              hint.addAttachment(fixture.attachment3)
-              return event
-            }
+    val sut = fixture.getSut { options ->
+      options.addEventProcessor(
+        object : EventProcessor {
+          override fun process(event: SentryEvent, hint: Hint): SentryEvent? {
+            assertEquals(listOf(fixture.attachment, fixture.attachment2), hint.attachments)
+            hint.addAttachment(fixture.attachment3)
+            return event
+          }
 
-            override fun process(transaction: SentryTransaction, hint: Hint): SentryTransaction? {
-              return transaction
-            }
+          override fun process(transaction: SentryTransaction, hint: Hint): SentryTransaction? {
+            return transaction
           }
-        )
-      }
+        }
+      )
+    }
 
     val scope = givenScopeWithStartedSession()
     scope.addAttachment(fixture.attachment2)
@@ -2719,21 +2719,20 @@ class SentryClientTest {
 
   @Test
   fun `can replace attachments in eventProcessor`() {
-    val sut =
-      fixture.getSut { options ->
-        options.addEventProcessor(
-          object : EventProcessor {
-            override fun process(event: SentryEvent, hint: Hint): SentryEvent? {
-              hint.replaceAttachments(listOf(fixture.attachment3))
-              return event
-            }
+    val sut = fixture.getSut { options ->
+      options.addEventProcessor(
+        object : EventProcessor {
+          override fun process(event: SentryEvent, hint: Hint): SentryEvent? {
+            hint.replaceAttachments(listOf(fixture.attachment3))
+            return event
+          }
 
-            override fun process(transaction: SentryTransaction, hint: Hint): SentryTransaction? {
-              return transaction
-            }
+          override fun process(transaction: SentryTransaction, hint: Hint): SentryTransaction? {
+            return transaction
           }
-        )
-      }
+        }
+      )
+    }
 
     val scope = givenScopeWithStartedSession()
     scope.addAttachment(fixture.attachment2)
@@ -2784,22 +2783,21 @@ class SentryClientTest {
 
   @Test
   fun `can add to attachments in eventProcessor for transactions`() {
-    val sut =
-      fixture.getSut { options ->
-        options.addEventProcessor(
-          object : EventProcessor {
-            override fun process(event: SentryEvent, hint: Hint): SentryEvent? {
-              return event
-            }
+    val sut = fixture.getSut { options ->
+      options.addEventProcessor(
+        object : EventProcessor {
+          override fun process(event: SentryEvent, hint: Hint): SentryEvent? {
+            return event
+          }
 
-            override fun process(transaction: SentryTransaction, hint: Hint): SentryTransaction? {
-              assertEquals(listOf(fixture.attachment, fixture.attachment2), hint.attachments)
-              hint.addAttachment(fixture.attachment3)
-              return transaction
-            }
+          override fun process(transaction: SentryTransaction, hint: Hint): SentryTransaction? {
+            assertEquals(listOf(fixture.attachment, fixture.attachment2), hint.attachments)
+            hint.addAttachment(fixture.attachment3)
+            return transaction
           }
-        )
-      }
+        }
+      )
+    }
 
     val scope = givenScopeWithStartedSession()
     scope.addAttachment(fixture.attachment2)
@@ -2820,21 +2818,20 @@ class SentryClientTest {
 
   @Test
   fun `can replace attachments in eventProcessor for transactions`() {
-    val sut =
-      fixture.getSut { options ->
-        options.addEventProcessor(
-          object : EventProcessor {
-            override fun process(event: SentryEvent, hint: Hint): SentryEvent? {
-              return event
-            }
+    val sut = fixture.getSut { options ->
+      options.addEventProcessor(
+        object : EventProcessor {
+          override fun process(event: SentryEvent, hint: Hint): SentryEvent? {
+            return event
+          }
 
-            override fun process(transaction: SentryTransaction, hint: Hint): SentryTransaction? {
-              hint.replaceAttachments(listOf(fixture.attachment3))
-              return transaction
-            }
+          override fun process(transaction: SentryTransaction, hint: Hint): SentryTransaction? {
+            hint.replaceAttachments(listOf(fixture.attachment3))
+            return transaction
           }
-        )
-      }
+        }
+      )
+    }
 
     val scope = givenScopeWithStartedSession()
     scope.addAttachment(fixture.attachment2)
@@ -2855,8 +2852,9 @@ class SentryClientTest {
 
   @Test
   fun `passing attachments via hint into breadcrumb ignores them`() {
-    val sut =
-      fixture.getSut { options -> options.setBeforeBreadcrumb { breadcrumb, hints -> breadcrumb } }
+    val sut = fixture.getSut { options ->
+      options.setBeforeBreadcrumb { breadcrumb, hints -> breadcrumb }
+    }
 
     val scope = givenScopeWithStartedSession()
     scope.addBreadcrumb(
@@ -2871,13 +2869,12 @@ class SentryClientTest {
 
   @Test
   fun `adding attachments in beforeBreadcrumb ignores them`() {
-    val sut =
-      fixture.getSut { options ->
-        options.setBeforeBreadcrumb { breadcrumb, hints ->
-          hints.addAttachment(fixture.attachment)
-          breadcrumb
-        }
+    val sut = fixture.getSut { options ->
+      options.setBeforeBreadcrumb { breadcrumb, hints ->
+        hints.addAttachment(fixture.attachment)
+        breadcrumb
       }
+    }
 
     val scope = givenScopeWithStartedSession()
     scope.addBreadcrumb(Breadcrumb.info("hello from breadcrumb"))
@@ -3160,11 +3157,11 @@ class SentryClientTest {
   @Test
   fun `beforeEnvelopeCallback is executed`() {
     var beforeEnvelopeCalled = false
-    val sut =
-      fixture.getSut { options ->
-        options.beforeEnvelopeCallback =
-          SentryOptions.BeforeEnvelopeCallback { _, _ -> beforeEnvelopeCalled = true }
+    val sut = fixture.getSut { options ->
+      options.beforeEnvelopeCallback = SentryOptions.BeforeEnvelopeCallback { _, _ ->
+        beforeEnvelopeCalled = true
       }
+    }
 
     sut.captureEvent(SentryEvent(), Hint())
 
@@ -3173,11 +3170,11 @@ class SentryClientTest {
 
   @Test
   fun `beforeEnvelopeCallback may fail, but the transport is still sends the envelope `() {
-    val sut =
-      fixture.getSut { options ->
-        options.beforeEnvelopeCallback =
-          SentryOptions.BeforeEnvelopeCallback { _, _ -> RuntimeException("hook failed") }
+    val sut = fixture.getSut { options ->
+      options.beforeEnvelopeCallback = SentryOptions.BeforeEnvelopeCallback { _, _ ->
+        RuntimeException("hook failed")
       }
+    }
 
     sut.captureEvent(SentryEvent(), Hint())
     verify(fixture.transport).send(anyOrNull(), anyOrNull())
@@ -3444,7 +3441,9 @@ class SentryClientTest {
       }
     )
     fixture.sentryOptions.sessionReplay.beforeErrorSampling =
-      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ -> false }
+      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ ->
+        false
+      }
     val sut = fixture.getSut()
 
     sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) })
@@ -3462,7 +3461,9 @@ class SentryClientTest {
       }
     )
     fixture.sentryOptions.sessionReplay.beforeErrorSampling =
-      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ -> true }
+      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ ->
+        true
+      }
     val sut = fixture.getSut()
 
     sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) })
@@ -3496,7 +3497,9 @@ class SentryClientTest {
       }
     )
     fixture.sentryOptions.sessionReplay.beforeErrorSampling =
-      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ -> throw RuntimeException("test") }
+      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ ->
+        throw RuntimeException("test")
+      }
     val sut = fixture.getSut()
 
     sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) })
diff --git a/sentry/src/test/java/io/sentry/SentryTest.kt b/sentry/src/test/java/io/sentry/SentryTest.kt
index 9da52c39b5a..8d05697fda4 100644
--- a/sentry/src/test/java/io/sentry/SentryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTest.kt
@@ -509,11 +509,10 @@ class SentryTest {
       initForTest {
         it.dsn = dsn
         it.isDebug = true
-        it.beforeSend =
-          SentryOptions.BeforeSendCallback { event, hint ->
-            capturedEvents.add(event)
-            event
-          }
+        it.beforeSend = SentryOptions.BeforeSendCallback { event, hint ->
+          capturedEvents.add(event)
+          event
+        }
       }
     }
     thread.start()
@@ -533,8 +532,9 @@ class SentryTest {
 
     assertEquals(2, capturedEvents.size)
     val mainCloneEvent = capturedEvents.firstOrNull { it.message?.formatted == "messageMainClone" }
-    val currentScopesEvent =
-      capturedEvents.firstOrNull { it.message?.formatted == "messageCurrent" }
+    val currentScopesEvent = capturedEvents.firstOrNull {
+      it.message?.formatted == "messageCurrent"
+    }
 
     assertNotNull(mainCloneEvent)
     assertNotNull(mainCloneEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbMainClone" })
@@ -563,11 +563,10 @@ class SentryTest {
         {
           it.dsn = dsn
           it.isDebug = true
-          it.beforeSend =
-            SentryOptions.BeforeSendCallback { event, hint ->
-              capturedEvents.add(event)
-              event
-            }
+          it.beforeSend = SentryOptions.BeforeSendCallback { event, hint ->
+            capturedEvents.add(event)
+            event
+          }
         },
         true,
       )
@@ -589,8 +588,9 @@ class SentryTest {
 
     assertEquals(2, capturedEvents.size)
     val mainCloneEvent = capturedEvents.firstOrNull { it.message?.formatted == "messageMainClone" }
-    val currentScopesEvent =
-      capturedEvents.firstOrNull { it.message?.formatted == "messageCurrent" }
+    val currentScopesEvent = capturedEvents.firstOrNull {
+      it.message?.formatted == "messageCurrent"
+    }
 
     assertNotNull(mainCloneEvent)
     assertNotNull(mainCloneEvent.breadcrumbs?.firstOrNull { it.message == "breadcrumbMainClone" })
diff --git a/sentry/src/test/java/io/sentry/SentryWrapperTest.kt b/sentry/src/test/java/io/sentry/SentryWrapperTest.kt
index 31c06fab5ad..0ed46d8fa38 100644
--- a/sentry/src/test/java/io/sentry/SentryWrapperTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryWrapperTest.kt
@@ -66,11 +66,10 @@ class SentryWrapperTest {
 
     initForTest {
       it.dsn = dsn
-      it.beforeSend =
-        SentryOptions.BeforeSendCallback { event, hint ->
-          capturedEvents.add(event)
-          event
-        }
+      it.beforeSend = SentryOptions.BeforeSendCallback { event, hint ->
+        capturedEvents.add(event)
+        event
+      }
     }
 
     Sentry.addBreadcrumb("MyOriginalBreadcrumbBefore")
@@ -119,11 +118,10 @@ class SentryWrapperTest {
 
     initForTest {
       it.dsn = dsn
-      it.beforeSend =
-        SentryOptions.BeforeSendCallback { event, hint ->
-          capturedEvents.add(event)
-          event
-        }
+      it.beforeSend = SentryOptions.BeforeSendCallback { event, hint ->
+        capturedEvents.add(event)
+        event
+      }
     }
 
     Sentry.addBreadcrumb("MyOriginalBreadcrumbBefore")
@@ -201,11 +199,10 @@ class SentryWrapperTest {
 
     initForTest {
       it.dsn = dsn
-      it.beforeSend =
-        SentryOptions.BeforeSendCallback { event, hint ->
-          capturedEvents.add(event)
-          event
-        }
+      it.beforeSend = SentryOptions.BeforeSendCallback { event, hint ->
+        capturedEvents.add(event)
+        event
+      }
     }
 
     Sentry.addBreadcrumb("MyOriginalBreadcrumbBefore")
diff --git a/sentry/src/test/java/io/sentry/UncaughtExceptionHandlerIntegrationTest.kt b/sentry/src/test/java/io/sentry/UncaughtExceptionHandlerIntegrationTest.kt
index 494b7f8a0bc..02da3b9a335 100644
--- a/sentry/src/test/java/io/sentry/UncaughtExceptionHandlerIntegrationTest.kt
+++ b/sentry/src/test/java/io/sentry/UncaughtExceptionHandlerIntegrationTest.kt
@@ -445,15 +445,14 @@ class UncaughtExceptionHandlerIntegrationTest {
     whenever(scopes4.globalScope).thenReturn(mock<IScope>())
     whenever(scopes5.globalScope).thenReturn(mock<IScope>())
 
-    val integrations =
-      scopesList.map { scope ->
-        CompletableFuture.supplyAsync(
-          {
-            UncaughtExceptionHandlerIntegration(handler).apply { register(scope, fixture.options) }
-          },
-          executor,
-        )
-      }
+    val integrations = scopesList.map { scope ->
+      CompletableFuture.supplyAsync(
+        {
+          UncaughtExceptionHandlerIntegration(handler).apply { register(scope, fixture.options) }
+        },
+        executor,
+      )
+    }
 
     CompletableFuture.allOf(*integrations.toTypedArray()).get()
 
diff --git a/sentry/src/test/java/io/sentry/clientreport/ClientReportMultiThreadingTest.kt b/sentry/src/test/java/io/sentry/clientreport/ClientReportMultiThreadingTest.kt
index fb62ee4a454..7f14c987438 100644
--- a/sentry/src/test/java/io/sentry/clientreport/ClientReportMultiThreadingTest.kt
+++ b/sentry/src/test/java/io/sentry/clientreport/ClientReportMultiThreadingTest.kt
@@ -118,10 +118,9 @@ class ClientReportMultiThreadingTest {
     println("took ${t2 - t1}ms")
 
     clientReportRecorder.resetCountsAndGenerateClientReport()?.let { clientReports.add(it) }
-    val numberOfLostItems =
-      clientReports.sumOf { clientReport ->
-        clientReport.discardedEvents.sumOf { it.quantity.toInt() }
-      }
+    val numberOfLostItems = clientReports.sumOf { clientReport ->
+      clientReport.discardedEvents.sumOf { it.quantity.toInt() }
+    }
 
     assertEquals(numberOfIncrementThreads * numberOfIncrementsPerThread, numberOfLostItems)
   }
diff --git a/sentry/src/test/java/io/sentry/transport/QueuedThreadPoolExecutorTest.kt b/sentry/src/test/java/io/sentry/transport/QueuedThreadPoolExecutorTest.kt
index e8e97e95c81..0c22a88aa87 100644
--- a/sentry/src/test/java/io/sentry/transport/QueuedThreadPoolExecutorTest.kt
+++ b/sentry/src/test/java/io/sentry/transport/QueuedThreadPoolExecutorTest.kt
@@ -145,11 +145,10 @@ class QueuedThreadPoolExecutorTest {
     val jobBlocker2 = CountDownLatch(1)
     val sync2 = CountDownLatch(1)
 
-    f =
-      sut.submit {
-        sync2.countDown()
-        jobBlocker2.await()
-      }
+    f = sut.submit {
+      sync2.countDown()
+      jobBlocker2.await()
+    }
     assertFalse(
       f.isCancelled,
       "A task should be successfully enqueued after making a place in the queue",

From bcd3e76a8033a30cf291fc84c726d40205b21db2 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 15 Jul 2026 11:16:35 +0200
Subject: [PATCH 296/391] perf: Avoid per-transaction Timer thread in
 SentryTracer (JAVA-596) (#5670)

* perf: Avoid per-transaction Timer thread in SentryTracer (JAVA-570)

Transactions with an idle or deadline timeout each created a
java.util.Timer, which spawns a thread synchronously on the calling
thread (often the main thread on Android). At scale (screen loads, HTTP
spans) this was the dominant source of SDK thread churn.

Schedule the idle/deadline timeouts on a dedicated, shared
ISentryExecutorService held by SentryOptions instead, so no thread is
created per transaction. It is kept separate from the main executor so
timeout callbacks (which finish transactions) don't contend with cached
event sending, and it is not prewarmed: its single worker thread is
spawned lazily on the first scheduled timeout and reused thereafter. The
dedicated executor uses removeOnCancelPolicy so cancelled timeouts (idle
timers are rescheduled per child span) don't accumulate in its queue. On
finish only the scheduled futures are cancelled; the executor is closed
with the SDK.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* fix(core): Keep timer executor alive across SDK restart (JAVA-570)

The shared timer executor introduced for transaction idle/deadline
timeouts was shut down on every Scopes.close(), including SDK restart.
This cancelled the pending idle timeout of any transaction started
before the restart (e.g. an in-flight activity transaction), so it
never auto-finished and its envelope was never sent.

Only close the timer executor on a full close, not on restart, matching
the pre-existing per-transaction Timer behaviour. Enable core-thread
timeout on the timer executor so the instance abandoned by a restart
self-terminates once idle instead of leaking a thread.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor(core): Look up shared timer executor on demand (JAVA-570)

SentryTracer cached the shared timer executor in a field for the
lifetime of the transaction. Replace that field with a boolean flag
tracking whether timeouts may still be scheduled, and fetch the
executor from the options each time one is scheduled. This ensures the
tracer always uses the executor currently held by the options (e.g. the
fresh one installed after an SDK restart) rather than a stale reference.

Also make the timer executor's keep-alive duration a constructor
argument backed by the named TIMER_KEEP_ALIVE_SECONDS constant, and
raise it from 10s to 30s so the shared worker thread is less likely to
be torn down and respawned between transactions under normal use.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  4 +
 .../core/ActivityLifecycleIntegrationTest.kt  |  3 +
 sentry/api/sentry.api                         |  2 +
 sentry/src/main/java/io/sentry/Scopes.java    |  6 ++
 sentry/src/main/java/io/sentry/Sentry.java    |  6 ++
 .../java/io/sentry/SentryExecutorService.java | 19 +++++
 .../main/java/io/sentry/SentryOptions.java    | 42 +++++++++++
 .../src/main/java/io/sentry/SentryTracer.java | 75 +++++++++----------
 sentry/src/test/java/io/sentry/ScopesTest.kt  | 26 +++++++
 .../io/sentry/SentryExecutorServiceTest.kt    | 17 +++++
 .../test/java/io/sentry/SentryTracerTest.kt   | 44 +++++------
 11 files changed, 182 insertions(+), 62 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index af29b22ccb5..17642fb819f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -35,6 +35,10 @@
 - Prevent logs and metrics from remaining queued after a flush scheduling race ([#5756](https://github.com/getsentry/sentry-java/pull/5756))
 - Fix main thread identification for tombstone (native crash) events ([#5742](https://github.com/getsentry/sentry-java/pull/5742))
 
+### Performance
+
+- Schedule transaction idle/deadline timeouts on a shared, dedicated executor instead of spawning a `Timer` thread per transaction ([#5670](https://github.com/getsentry/sentry-java/pull/5670))
+
 ### Dependencies
 
 - Bump OpenTelemetry to support Spring Boot 4.1 ([#5573](https://github.com/getsentry/sentry-java/pull/5573))
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
index 1d8fa06f3bb..166129f601b 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
@@ -23,6 +23,7 @@ import io.sentry.Scopes
 import io.sentry.Sentry
 import io.sentry.SentryDate
 import io.sentry.SentryDateProvider
+import io.sentry.SentryExecutorService
 import io.sentry.SentryNanotimeDate
 import io.sentry.SentryTraceHeader
 import io.sentry.SentryTracer
@@ -919,6 +920,8 @@ class ActivityLifecycleIntegrationTest {
           it.idleTimeout = 100
         }
       )
+    // the transaction idle timeout is scheduled on the dedicated timer executor
+    fixture.options.timerExecutorService = SentryExecutorService()
     sut.register(fixture.scopes, fixture.options)
     sut.onActivityCreated(activity, fixture.bundle)
 
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 00183bc9b30..e0bf144178f 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -3719,6 +3719,7 @@ public class io/sentry/SentryOptions {
 	public fun getSslSocketFactory ()Ljavax/net/ssl/SSLSocketFactory;
 	public fun getTags ()Ljava/util/Map;
 	public fun getThreadChecker ()Lio/sentry/util/thread/IThreadChecker;
+	public fun getTimerExecutorService ()Lio/sentry/ISentryExecutorService;
 	public fun getTracePropagationTargets ()Ljava/util/List;
 	public fun getTracesSampleRate ()Ljava/lang/Double;
 	public fun getTracesSampler ()Lio/sentry/SentryOptions$TracesSamplerCallback;
@@ -3884,6 +3885,7 @@ public class io/sentry/SentryOptions {
 	public fun setStrictTraceContinuation (Z)V
 	public fun setTag (Ljava/lang/String;Ljava/lang/String;)V
 	public fun setThreadChecker (Lio/sentry/util/thread/IThreadChecker;)V
+	public fun setTimerExecutorService (Lio/sentry/ISentryExecutorService;)V
 	public fun setTraceOptionsRequests (Z)V
 	public fun setTracePropagationTargets (Ljava/util/List;)V
 	public fun setTraceSampling (Z)V
diff --git a/sentry/src/main/java/io/sentry/Scopes.java b/sentry/src/main/java/io/sentry/Scopes.java
index 3b67b94916e..936a331e3d4 100644
--- a/sentry/src/main/java/io/sentry/Scopes.java
+++ b/sentry/src/main/java/io/sentry/Scopes.java
@@ -467,6 +467,12 @@ public void close(final boolean isRestarting) {
         getOptions().getContinuousProfiler().close(true);
         getOptions().getCompositePerformanceCollector().close();
         getOptions().getConnectionStatusProvider().close();
+        // On restart we intentionally leave the timer executor running so that pending idle/
+        // deadline timeouts of transactions started before the restart still fire and finish
+        // those transactions. It self-terminates once idle (allowCoreThreadTimeOut).
+        if (!isRestarting) {
+          getOptions().getTimerExecutorService().close(getOptions().getShutdownTimeoutMillis());
+        }
         final @NotNull ISentryExecutorService executorService = getOptions().getExecutorService();
         if (isRestarting) {
           try {
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index 275e2a3c614..8bba9d92e4f 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -353,6 +353,12 @@ private static void init(final @NotNull SentryOptions options, final boolean glo
           options.setExecutorService(new SentryExecutorService(options));
         }
 
+        if (options.getTimerExecutorService().isClosed()) {
+          options.setTimerExecutorService(
+              new SentryExecutorService(
+                  options, true, SentryExecutorService.TIMER_KEEP_ALIVE_SECONDS, TimeUnit.SECONDS));
+        }
+
         // load lazy fields of the options in a separate thread
         try {
           options.getExecutorService().submit(() -> options.loadLazyFields());
diff --git a/sentry/src/main/java/io/sentry/SentryExecutorService.java b/sentry/src/main/java/io/sentry/SentryExecutorService.java
index 1936bb9c360..a469dca5853 100644
--- a/sentry/src/main/java/io/sentry/SentryExecutorService.java
+++ b/sentry/src/main/java/io/sentry/SentryExecutorService.java
@@ -22,6 +22,12 @@ public final class SentryExecutorService implements ISentryExecutorService {
    */
   private static final int MAX_QUEUE_SIZE = 271;
 
+  /**
+   * How long the timer executor's worker thread stays alive while idle before self-terminating, so
+   * an instance abandoned on SDK restart doesn't leak a live thread once its queue drains.
+   */
+  static final long TIMER_KEEP_ALIVE_SECONDS = 30;
+
   private final @NotNull ScheduledThreadPoolExecutor executorService;
   private final @NotNull AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
 
@@ -39,6 +45,19 @@ public SentryExecutorService(final @Nullable SentryOptions options) {
     this(new ScheduledThreadPoolExecutor(1, new SentryExecutorServiceThreadFactory()), options);
   }
 
+  SentryExecutorService(
+      final @Nullable SentryOptions options,
+      final boolean removeOnCancelPolicy,
+      final long keepAliveTime,
+      final @NotNull TimeUnit keepAliveTimeUnit) {
+    this(options);
+    // removes cancelled tasks from the work queue immediately instead of leaving them until their
+    // scheduled time; useful for executors that frequently reschedule (e.g. transaction timeouts)
+    executorService.setRemoveOnCancelPolicy(removeOnCancelPolicy);
+    executorService.setKeepAliveTime(keepAliveTime, keepAliveTimeUnit);
+    executorService.allowCoreThreadTimeOut(true);
+  }
+
   public SentryExecutorService() {
     this(new ScheduledThreadPoolExecutor(1, new SentryExecutorServiceThreadFactory()), null);
   }
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 3c55f5e1cfa..cde0c37ba90 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -44,6 +44,7 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import javax.net.ssl.SSLSocketFactory;
 import org.jetbrains.annotations.ApiStatus;
@@ -317,6 +318,14 @@ public class SentryOptions {
   /** Sentry Executor Service that sends cached events and envelopes on App. start. */
   private @NotNull ISentryExecutorService executorService = NoOpSentryExecutorService.getInstance();
 
+  /**
+   * Dedicated executor for scheduling transaction idle/deadline timeouts. Kept separate from {@link
+   * #executorService} so timeout callbacks (which finish transactions) don't contend with cached
+   * event sending.
+   */
+  private @NotNull ISentryExecutorService timerExecutorService =
+      NoOpSentryExecutorService.getInstance();
+
   /**
    * Whether SpotlightIntegration has already been loaded via reflection. This prevents re-adding it
    * if the user removed it in their configuration callback and activate() is called again.
@@ -683,6 +692,15 @@ public void activate() {
       executorService = new SentryExecutorService(this);
     }
 
+    if (timerExecutorService instanceof NoOpSentryExecutorService) {
+      // Not prewarmed: its single worker thread is spawned lazily on the first scheduled timeout
+      // and then reused across all transactions. removeOnCancelPolicy keeps the work queue from
+      // accumulating cancelled timeouts (idle timers are cancelled and rescheduled per child span).
+      timerExecutorService =
+          new SentryExecutorService(
+              this, true, SentryExecutorService.TIMER_KEEP_ALIVE_SECONDS, TimeUnit.SECONDS);
+    }
+
     // SpotlightIntegration is loaded via reflection to allow the sentry-spotlight module
     // to be excluded from release builds, preventing insecure HTTP URLs from appearing in APKs.
     // Only attempt once to avoid re-adding after user removal in their configuration callback.
@@ -1570,6 +1588,30 @@ public void setExecutorService(final @NotNull ISentryExecutorService executorSer
     }
   }
 
+  /**
+   * Returns the dedicated executor used to schedule transaction idle/deadline timeouts.
+   *
+   * @return the timer executor service
+   */
+  @ApiStatus.Internal
+  @NotNull
+  public ISentryExecutorService getTimerExecutorService() {
+    return timerExecutorService;
+  }
+
+  /**
+   * Sets the dedicated executor used to schedule transaction idle/deadline timeouts.
+   *
+   * @param timerExecutorService the timer executor service
+   */
+  @ApiStatus.Internal
+  @TestOnly
+  public void setTimerExecutorService(final @NotNull ISentryExecutorService timerExecutorService) {
+    if (timerExecutorService != null) {
+      this.timerExecutorService = timerExecutorService;
+    }
+  }
+
   /**
    * Returns the connection timeout in milliseconds.
    *
diff --git a/sentry/src/main/java/io/sentry/SentryTracer.java b/sentry/src/main/java/io/sentry/SentryTracer.java
index 9729ac406b1..723538b9924 100644
--- a/sentry/src/main/java/io/sentry/SentryTracer.java
+++ b/sentry/src/main/java/io/sentry/SentryTracer.java
@@ -12,9 +12,8 @@
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
-import java.util.Timer;
-import java.util.TimerTask;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import org.jetbrains.annotations.ApiStatus;
@@ -37,10 +36,12 @@ public final class SentryTracer implements ITransaction {
    */
   private @NotNull FinishStatus finishStatus = FinishStatus.NOT_FINISHED;
 
-  private volatile @Nullable TimerTask idleTimeoutTask;
-  private volatile @Nullable TimerTask deadlineTimeoutTask;
+  private volatile @Nullable Future<?> idleTimeoutFuture;
+  private volatile @Nullable Future<?> deadlineTimeoutFuture;
 
-  private volatile @Nullable Timer timer = null;
+  // Whether timeout tasks may still be scheduled. Set to false once the tracer is finished. The
+  // executor itself is owned by the options (shared SDK-wide) and obtained from there when needed.
+  private volatile boolean timersEnabled = false;
   private final @NotNull AutoClosableReentrantLock timerLock = new AutoClosableReentrantLock();
   private final @NotNull AutoClosableReentrantLock tracerLock = new AutoClosableReentrantLock();
 
@@ -99,7 +100,7 @@ public SentryTracer(
 
     if (transactionOptions.getIdleTimeout() != null
         || transactionOptions.getDeadlineTimeout() != null) {
-      timer = new Timer(true);
+      timersEnabled = true;
 
       scheduleDeadlineTimeout();
       scheduleFinish();
@@ -109,22 +110,19 @@ public SentryTracer(
   @Override
   public void scheduleFinish() {
     try (final @NotNull ISentryLifecycleToken ignored = timerLock.acquire()) {
-      if (timer != null) {
+      if (timersEnabled) {
         final @Nullable Long idleTimeout = transactionOptions.getIdleTimeout();
 
         if (idleTimeout != null) {
           cancelIdleTimer();
           isIdleFinishTimerRunning.set(true);
-          idleTimeoutTask =
-              new TimerTask() {
-                @Override
-                public void run() {
-                  onIdleTimeoutReached();
-                }
-              };
 
           try {
-            timer.schedule(idleTimeoutTask, idleTimeout);
+            idleTimeoutFuture =
+                scopes
+                    .getOptions()
+                    .getTimerExecutorService()
+                    .schedule(this::onIdleTimeoutReached, idleTimeout);
           } catch (Throwable e) {
             scopes
                 .getOptions()
@@ -265,13 +263,12 @@ public void finish(
           });
       final SentryTransaction transaction = new SentryTransaction(this);
 
-      if (timer != null) {
+      if (timersEnabled) {
         try (final @NotNull ISentryLifecycleToken ignored = timerLock.acquire()) {
-          if (timer != null) {
+          if (timersEnabled) {
             cancelIdleTimer();
             cancelDeadlineTimer();
-            timer.cancel();
-            timer = null;
+            timersEnabled = false;
           }
         }
       }
@@ -295,10 +292,10 @@ public void finish(
 
   private void cancelIdleTimer() {
     try (final @NotNull ISentryLifecycleToken ignored = timerLock.acquire()) {
-      if (idleTimeoutTask != null) {
-        idleTimeoutTask.cancel();
+      if (idleTimeoutFuture != null) {
+        idleTimeoutFuture.cancel(false);
         isIdleFinishTimerRunning.set(false);
-        idleTimeoutTask = null;
+        idleTimeoutFuture = null;
       }
     }
   }
@@ -307,18 +304,15 @@ private void scheduleDeadlineTimeout() {
     final @Nullable Long deadlineTimeOut = transactionOptions.getDeadlineTimeout();
     if (deadlineTimeOut != null) {
       try (final @NotNull ISentryLifecycleToken ignored = timerLock.acquire()) {
-        if (timer != null) {
+        if (timersEnabled) {
           cancelDeadlineTimer();
           isDeadlineTimerRunning.set(true);
-          deadlineTimeoutTask =
-              new TimerTask() {
-                @Override
-                public void run() {
-                  onDeadlineTimeoutReached();
-                }
-              };
           try {
-            timer.schedule(deadlineTimeoutTask, deadlineTimeOut);
+            deadlineTimeoutFuture =
+                scopes
+                    .getOptions()
+                    .getTimerExecutorService()
+                    .schedule(this::onDeadlineTimeoutReached, deadlineTimeOut);
           } catch (Throwable e) {
             scopes
                 .getOptions()
@@ -335,10 +329,10 @@ public void run() {
 
   private void cancelDeadlineTimer() {
     try (final @NotNull ISentryLifecycleToken ignored = timerLock.acquire()) {
-      if (deadlineTimeoutTask != null) {
-        deadlineTimeoutTask.cancel();
+      if (deadlineTimeoutFuture != null) {
+        deadlineTimeoutFuture.cancel(false);
         isDeadlineTimerRunning.set(false);
-        deadlineTimeoutTask = null;
+        deadlineTimeoutFuture = null;
       }
     }
   }
@@ -973,20 +967,19 @@ Span getRoot() {
 
   @TestOnly
   @Nullable
-  TimerTask getIdleTimeoutTask() {
-    return idleTimeoutTask;
+  Future<?> getIdleTimeoutFuture() {
+    return idleTimeoutFuture;
   }
 
   @TestOnly
   @Nullable
-  TimerTask getDeadlineTimeoutTask() {
-    return deadlineTimeoutTask;
+  Future<?> getDeadlineTimeoutFuture() {
+    return deadlineTimeoutFuture;
   }
 
   @TestOnly
-  @Nullable
-  Timer getTimer() {
-    return timer;
+  boolean areTimersEnabled() {
+    return timersEnabled;
   }
 
   @TestOnly
diff --git a/sentry/src/test/java/io/sentry/ScopesTest.kt b/sentry/src/test/java/io/sentry/ScopesTest.kt
index 4b9b3095d53..9d598aec885 100644
--- a/sentry/src/test/java/io/sentry/ScopesTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopesTest.kt
@@ -1946,6 +1946,32 @@ class ScopesTest {
     verify(executor).close(any())
   }
 
+  @Test
+  fun `Scopes with isRestarting true should not close the timer executor`() {
+    val timerExecutor = mock<ISentryExecutorService>()
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        setTimerExecutorService(timerExecutor)
+      }
+    val sut = createScopes(options)
+    sut.close(true)
+    verify(timerExecutor, never()).close(any())
+  }
+
+  @Test
+  fun `Scopes with isRestarting false should close the timer executor`() {
+    val timerExecutor = mock<ISentryExecutorService>()
+    val options =
+      SentryOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        setTimerExecutorService(timerExecutor)
+      }
+    val sut = createScopes(options)
+    sut.close(false)
+    verify(timerExecutor).close(any())
+  }
+
   @Test
   fun `Scopes close should clear the scope`() {
     val options = SentryOptions().apply { dsn = "https://key@sentry.io/proj" }
diff --git a/sentry/src/test/java/io/sentry/SentryExecutorServiceTest.kt b/sentry/src/test/java/io/sentry/SentryExecutorServiceTest.kt
index 57dfb578ee9..153feecb4a4 100644
--- a/sentry/src/test/java/io/sentry/SentryExecutorServiceTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryExecutorServiceTest.kt
@@ -1,5 +1,6 @@
 package io.sentry
 
+import io.sentry.test.getProperty
 import java.util.concurrent.BlockingQueue
 import java.util.concurrent.Callable
 import java.util.concurrent.CancellationException
@@ -93,6 +94,22 @@ class SentryExecutorServiceTest {
     sentryExecutor.close(15000)
   }
 
+  @Test
+  fun `SentryExecutorService enables removeOnCancelPolicy when requested`() {
+    val sentryExecutor = SentryExecutorService(null, true, 30, TimeUnit.SECONDS)
+    val executor = sentryExecutor.getProperty<ScheduledThreadPoolExecutor>("executorService")
+    assertTrue(executor.removeOnCancelPolicy)
+    sentryExecutor.close(15000)
+  }
+
+  @Test
+  fun `SentryExecutorService does not enable removeOnCancelPolicy by default`() {
+    val sentryExecutor = SentryExecutorService(null)
+    val executor = sentryExecutor.getProperty<ScheduledThreadPoolExecutor>("executorService")
+    assertFalse(executor.removeOnCancelPolicy)
+    sentryExecutor.close(15000)
+  }
+
   @Test
   fun `SentryExecutorService isClosed returns true if executor is shutdown`() {
     val executor = mock<ScheduledThreadPoolExecutor>()
diff --git a/sentry/src/test/java/io/sentry/SentryTracerTest.kt b/sentry/src/test/java/io/sentry/SentryTracerTest.kt
index 3b808dd2220..20eeafffe92 100644
--- a/sentry/src/test/java/io/sentry/SentryTracerTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTracerTest.kt
@@ -13,6 +13,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotEquals
 import kotlin.test.assertNotNull
+import kotlin.test.assertNotSame
 import kotlin.test.assertNull
 import kotlin.test.assertSame
 import kotlin.test.assertTrue
@@ -913,7 +914,7 @@ class SentryTracerTest {
   @Test
   fun `when initialized without deadlineTimeout, does not schedule finish timer`() {
     val transaction = fixture.getSut()
-    assertNull(transaction.deadlineTimeoutTask)
+    assertNull(transaction.deadlineTimeoutFuture)
   }
 
   @Test
@@ -921,7 +922,7 @@ class SentryTracerTest {
     val transaction = fixture.getSut(deadlineTimeout = 50)
 
     assertTrue(transaction.isDeadlineTimerRunning.get())
-    assertNotNull(transaction.deadlineTimeoutTask)
+    assertNotNull(transaction.deadlineTimeoutFuture)
   }
 
   @Test
@@ -949,7 +950,7 @@ class SentryTracerTest {
     transaction.finish(SpanStatus.OK)
 
     assertEquals(transaction.isDeadlineTimerRunning.get(), false)
-    assertNull(transaction.deadlineTimeoutTask)
+    assertNull(transaction.deadlineTimeoutFuture)
     assertEquals(transaction.isFinished, true)
     assertEquals(SpanStatus.OK, transaction.status)
     assertEquals(SpanStatus.OK, span.status)
@@ -958,26 +959,26 @@ class SentryTracerTest {
   @Test
   fun `when initialized with idleTimeout it has no influence on deadline timeout`() {
     val transaction = fixture.getSut(idleTimeout = 3000, deadlineTimeout = 20)
-    val deadlineTimeoutTask = transaction.deadlineTimeoutTask
+    val deadlineTimeoutFuture = transaction.deadlineTimeoutFuture
 
     val span = transaction.startChild("op")
     // when the span finishes, it re-schedules the idle task
     span.finish()
 
     // but the deadline timeout task should not be re-scheduled
-    assertEquals(deadlineTimeoutTask, transaction.deadlineTimeoutTask)
+    assertSame(deadlineTimeoutFuture, transaction.deadlineTimeoutFuture)
   }
 
   @Test
   fun `when initialized without idleTimeout, does not schedule finish timer`() {
     val transaction = fixture.getSut()
-    assertNull(transaction.idleTimeoutTask)
+    assertNull(transaction.idleTimeoutFuture)
   }
 
   @Test
   fun `when initialized with idleTimeout, schedules finish timer`() {
     val transaction = fixture.getSut(idleTimeout = 50)
-    assertNotNull(transaction.idleTimeoutTask)
+    assertNotNull(transaction.idleTimeoutFuture)
   }
 
   @Test
@@ -1008,22 +1009,23 @@ class SentryTracerTest {
 
     transaction.startChild("op")
 
-    assertNull(transaction.idleTimeoutTask)
+    assertNull(transaction.idleTimeoutFuture)
   }
 
   @Test
   fun `when a child is finished and the transaction is idle, resets the timer`() {
     val transaction = fixture.getSut(waitForChildren = true, idleTimeout = 3000)
 
-    val initialTime = transaction.idleTimeoutTask!!.scheduledExecutionTime()
+    val initialFuture = transaction.idleTimeoutFuture
 
     val span = transaction.startChild("op")
-    Thread.sleep(1)
     span.finish()
 
-    val timerAfterFinishingChild = transaction.idleTimeoutTask!!.scheduledExecutionTime()
+    // finishing the child re-schedules the idle timeout, replacing the pending future
+    val futureAfterFinishingChild = transaction.idleTimeoutFuture
 
-    assertTrue { timerAfterFinishingChild > initialTime }
+    assertNotNull(futureAfterFinishingChild)
+    assertNotSame(initialFuture, futureAfterFinishingChild)
   }
 
   @Test
@@ -1035,7 +1037,7 @@ class SentryTracerTest {
     Thread.sleep(1)
     span.finish()
 
-    assertNull(transaction.idleTimeoutTask)
+    assertNull(transaction.idleTimeoutFuture)
   }
 
   @Test
@@ -1080,7 +1082,7 @@ class SentryTracerTest {
         trimEnd = true,
         samplingDecision = TracesSamplingDecision(true),
       )
-    assertNotNull(transaction.timer)
+    assertTrue(transaction.areTimersEnabled())
   }
 
   @Test
@@ -1092,7 +1094,7 @@ class SentryTracerTest {
         trimEnd = true,
         samplingDecision = TracesSamplingDecision(true),
       )
-    assertNull(transaction.timer)
+    assertFalse(transaction.areTimersEnabled())
   }
 
   @Test
@@ -1104,9 +1106,9 @@ class SentryTracerTest {
         trimEnd = true,
         samplingDecision = TracesSamplingDecision(true),
       )
-    assertNotNull(transaction.timer)
+    assertTrue(transaction.areTimersEnabled())
     transaction.finish(SpanStatus.OK)
-    assertNull(transaction.timer)
+    assertFalse(transaction.areTimersEnabled())
   }
 
   @Test
@@ -1539,18 +1541,18 @@ class SentryTracerTest {
   }
 
   @Test
-  fun `when timer is cancelled, schedule finish does not crash`() {
+  fun `when timer executor is shut down, schedule finish does not crash`() {
     val tracer = fixture.getSut(idleTimeout = 50, deadlineTimeout = 100)
-    tracer.timer!!.cancel()
+    fixture.options.timerExecutorService.close(0)
     tracer.scheduleFinish()
   }
 
   @Test
-  fun `when timer is cancelled, schedule finish finishes the transaction immediately`() {
+  fun `when timer executor is shut down, schedule finish finishes the transaction immediately`() {
     val tracer = fixture.getSut(idleTimeout = 50)
     tracer.startChild("load").finish()
 
-    tracer.timer!!.cancel()
+    fixture.options.timerExecutorService.close(0)
     tracer.scheduleFinish()
 
     assertTrue(tracer.isFinished)

From a212e8f702c5fcfae9a26e73afd82bbd8f3927c5 Mon Sep 17 00:00:00 2001
From: "sentry-junior[bot]"
 <264270552+sentry-junior[bot]@users.noreply.github.com>
Date: Wed, 15 Jul 2026 20:01:18 +0200
Subject: [PATCH 297/391] feat(replay): Record segment names (transaction
 names) (#5763)

* feat(replay): Record segment names

Co-Authored-By: Gino Buenaflor <giancarlo.buenaflor@sentry.io>

* docs: Add replay segment names changelog entry

* Format code

* test(replay): Use realistic Android transaction name

Co-Authored-By: Gino Buenaflor <giancarlo.buenaflor@sentry.io>

* build: Update replay API dumps

* test(replay): Use realistic Android segment names

Co-Authored-By: Gino Buenaflor <giancarlo.buenaflor@sentry.io>

* Format code

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: Gino Buenaflor <giancarlo.buenaflor@sentry.io>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: Giancarlo Buenaflor <giancarlo_buenaflor@yahoo.com>
Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 CHANGELOG.md                                  |  2 +
 .../api/sentry-android-replay.api             |  1 +
 .../android/replay/ReplayIntegration.kt       |  7 +++
 .../replay/capture/BaseCaptureStrategy.kt     | 36 ++++++++-----
 .../android/replay/capture/CaptureStrategy.kt |  6 +++
 .../capture/SessionCaptureStrategyTest.kt     | 54 +++++++++++++++++++
 sentry/api/sentry.api                         |  5 ++
 .../java/io/sentry/NoOpReplayController.java  |  3 ++
 .../main/java/io/sentry/ReplayController.java |  3 ++
 .../src/main/java/io/sentry/SentryClient.java |  4 ++
 .../java/io/sentry/SentryReplayEvent.java     | 26 ++++++++-
 .../test/java/io/sentry/SentryClientTest.kt   | 20 +++++++
 .../SentryReplayEventSerializationTest.kt     |  1 +
 .../resources/json/sentry_replay_event.json   |  4 ++
 14 files changed, 157 insertions(+), 15 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 17642fb819f..cdc3e33452b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,8 @@
 
 ### Features
 
+- Session Replay: Record segment names (transaction names) ([#5763](https://github.com/getsentry/sentry-java/pull/5763))
+
 - Add `io.sentry:sentry-opentelemetry-bom` to align Sentry OpenTelemetry modules with tested OpenTelemetry dependencies ([#5629](https://github.com/getsentry/sentry-java/pull/5629))
   - Spring Boot Gradle plugin: add the Sentry BOM to `dependencyManagement`; explicit imports are applied after Spring Boot's implicit BOM
     ```kotlin
diff --git a/sentry-android-replay/api/sentry-android-replay.api b/sentry-android-replay/api/sentry-android-replay.api
index 12fe214176d..3efee26e37d 100644
--- a/sentry-android-replay/api/sentry-android-replay.api
+++ b/sentry-android-replay/api/sentry-android-replay.api
@@ -76,6 +76,7 @@ public final class io/sentry/android/replay/ReplayIntegration : io/sentry/IConne
 	public fun onWindowSizeChanged (II)V
 	public fun pause ()V
 	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
+	public fun registerSegmentName (Ljava/lang/String;)V
 	public fun registerTraceId (Lio/sentry/protocol/SentryId;)V
 	public fun resume ()V
 	public fun setBreadcrumbConverter (Lio/sentry/ReplayBreadcrumbConverter;)V
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
index bae0e411795..d9cd15d891a 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
@@ -297,6 +297,13 @@ public class ReplayIntegration(
     captureStrategy?.registerTraceId(traceId)
   }
 
+  override fun registerSegmentName(segmentName: String) {
+    if (!isEnabled.get() || !isRecording()) {
+      return
+    }
+    captureStrategy?.registerSegmentName(segmentName)
+  }
+
   private fun pauseInternal() {
     lifecycleLock.acquire().use {
       if (!isEnabled.get() || !lifecycle.isAllowed(PAUSED)) {
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
index fbc0ccfd4bc..f505d21a151 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt
@@ -54,7 +54,7 @@ internal abstract class BaseCaptureStrategy(
   internal companion object {
     private const val TAG = "CaptureStrategy"
     // https://github.com/getsentry/sentry-javascript/blob/30eb68fff5077211c30c61ba74625e66ab514870/packages/replay-internal/src/coreHandlers/handleAfterSendEvent.ts#L41
-    private const val MAX_TRACE_IDS = 100
+    private const val MAX_CONTEXT_VALUES = 100
   }
 
   private val gestureConverter = ReplayGestureConverter(dateProvider)
@@ -97,8 +97,9 @@ internal abstract class BaseCaptureStrategy(
     persistableAtomic(initialValue = false, propertyName = SEGMENT_KEY_FLUSHED)
 
   protected val currentEvents: Deque<RRWebEvent> = ConcurrentLinkedDeque()
-  private val traceIdsLock = Any()
-  private val currentTraceIds: MutableList<String> = mutableListOf()
+  private val replayContextLock = Any()
+  private val currentTraceIds: MutableSet<String> = linkedSetOf()
+  private val currentSegmentNames: MutableSet<String> = linkedSetOf()
 
   override fun start(segmentId: Int, replayId: SentryId, replayType: ReplayType?) {
     cache = replayCacheProvider?.invoke(replayId) ?: ReplayCache(options, replayId)
@@ -139,11 +140,12 @@ internal abstract class BaseCaptureStrategy(
     breadcrumbs: List<Breadcrumb>? = null,
     events: Deque<RRWebEvent> = this.currentEvents,
   ): ReplaySegment {
-    val traceIds =
-      synchronized(traceIdsLock) {
-        val ids = currentTraceIds.toList()
+    val (traceIds, segmentNames) =
+      synchronized(replayContextLock) {
+        val context = currentTraceIds.toList() to currentSegmentNames.toList()
         currentTraceIds.clear()
-        ids
+        currentSegmentNames.clear()
+        context
       }
     return createSegment(
       scopes,
@@ -162,6 +164,7 @@ internal abstract class BaseCaptureStrategy(
       breadcrumbs,
       events,
       traceIds,
+      segmentNames,
     )
   }
 
@@ -180,12 +183,19 @@ internal abstract class BaseCaptureStrategy(
 
   override fun registerTraceId(traceId: SentryId) {
     if (traceId != SentryId.EMPTY_ID) {
-      synchronized(traceIdsLock) {
-        if (currentTraceIds.size < MAX_TRACE_IDS) {
-          val id = traceId.toString()
-          if (!currentTraceIds.contains(id)) {
-            currentTraceIds.add(id)
-          }
+      synchronized(replayContextLock) {
+        if (currentTraceIds.size < MAX_CONTEXT_VALUES) {
+          currentTraceIds.add(traceId.toString())
+        }
+      }
+    }
+  }
+
+  override fun registerSegmentName(segmentName: String) {
+    if (segmentName.isNotEmpty()) {
+      synchronized(replayContextLock) {
+        if (currentSegmentNames.size < MAX_CONTEXT_VALUES) {
+          currentSegmentNames.add(segmentName)
         }
       }
     }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt
index 096a93741b2..780cdd92481 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/CaptureStrategy.kt
@@ -56,6 +56,8 @@ internal interface CaptureStrategy {
 
   fun registerTraceId(traceId: SentryId)
 
+  fun registerSegmentName(segmentName: String)
+
   companion object {
     private fun Breadcrumb?.isNetworkAvailable(): Boolean =
       this != null &&
@@ -88,6 +90,7 @@ internal interface CaptureStrategy {
       breadcrumbs: List<Breadcrumb>?,
       events: Deque<RRWebEvent>,
       traceIds: List<String> = emptyList(),
+      segmentNames: List<String> = emptyList(),
     ): ReplaySegment {
       val generatedVideo =
         cache?.createVideoOf(
@@ -127,6 +130,7 @@ internal interface CaptureStrategy {
         replayBreadcrumbs,
         events,
         traceIds,
+        segmentNames,
       )
     }
 
@@ -147,6 +151,7 @@ internal interface CaptureStrategy {
       breadcrumbs: List<Breadcrumb>,
       events: Deque<RRWebEvent>,
       traceIds: List<String>,
+      segmentNames: List<String>,
     ): ReplaySegment {
       val endTimestamp = DateUtils.getDateTime(segmentTimestamp.time + videoDuration)
       val replay =
@@ -159,6 +164,7 @@ internal interface CaptureStrategy {
           this.replayType = replayType
           this.videoFile = video
           this.traceIds = traceIds
+          this.segmentNames = segmentNames
         }
 
       val recordingPayload = mutableListOf<RRWebEvent>()
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt
index dd9e6c6ce1d..fc2354eb1c0 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/SessionCaptureStrategyTest.kt
@@ -562,4 +562,58 @@ class SessionCaptureStrategyTest {
         any(),
       )
   }
+
+  @Test
+  fun `registerSegmentName includes unique segment names in next segment and clears them`() {
+    val now =
+      System.currentTimeMillis() + (fixture.options.sessionReplay.sessionSegmentDuration * 5)
+    val strategy = fixture.getSut(dateProvider = { now })
+    strategy.start()
+    strategy.onConfigurationChanged(fixture.recorderConfig)
+
+    strategy.registerSegmentName("CheckoutActivity")
+    strategy.registerSegmentName("CheckoutActivity")
+    strategy.registerSegmentName("ProductDetailsActivity")
+
+    strategy.onScreenshotRecorded(mock<Bitmap>()) {}
+
+    verify(fixture.scopes)
+      .captureReplay(
+        argThat { event ->
+          event is SentryReplayEvent &&
+            event.segmentNames == listOf("CheckoutActivity", "ProductDetailsActivity")
+        },
+        any(),
+      )
+
+    strategy.onScreenshotRecorded(mock<Bitmap>()) {}
+
+    verify(fixture.scopes)
+      .captureReplay(
+        argThat { event ->
+          event is SentryReplayEvent && event.segmentId == 1 && event.segmentNames.isNullOrEmpty()
+        },
+        any(),
+      )
+  }
+
+  @Test
+  fun `registerSegmentName ignores empty names and limits names to 100`() {
+    val now =
+      System.currentTimeMillis() + (fixture.options.sessionReplay.sessionSegmentDuration * 5)
+    val strategy = fixture.getSut(dateProvider = { now })
+    strategy.start()
+    strategy.onConfigurationChanged(fixture.recorderConfig)
+
+    strategy.registerSegmentName("")
+    repeat(101) { strategy.registerSegmentName("ProductActivity$it") }
+
+    strategy.onScreenshotRecorded(mock<Bitmap>()) {}
+
+    verify(fixture.scopes)
+      .captureReplay(
+        argThat { event -> event is SentryReplayEvent && event.segmentNames?.size == 100 },
+        any(),
+      )
+  }
 }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index e0bf144178f..0e5aad4826b 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -1715,6 +1715,7 @@ public final class io/sentry/NoOpReplayController : io/sentry/ReplayController {
 	public fun isDebugMaskingOverlayEnabled ()Z
 	public fun isRecording ()Z
 	public fun pause ()V
+	public fun registerSegmentName (Ljava/lang/String;)V
 	public fun registerTraceId (Lio/sentry/protocol/SentryId;)V
 	public fun resume ()V
 	public fun setBreadcrumbConverter (Lio/sentry/ReplayBreadcrumbConverter;)V
@@ -2357,6 +2358,7 @@ public abstract interface class io/sentry/ReplayController : io/sentry/IReplayAp
 	public abstract fun isDebugMaskingOverlayEnabled ()Z
 	public abstract fun isRecording ()Z
 	public abstract fun pause ()V
+	public abstract fun registerSegmentName (Ljava/lang/String;)V
 	public abstract fun registerTraceId (Lio/sentry/protocol/SentryId;)V
 	public abstract fun resume ()V
 	public abstract fun setBreadcrumbConverter (Lio/sentry/ReplayBreadcrumbConverter;)V
@@ -4023,6 +4025,7 @@ public final class io/sentry/SentryReplayEvent : io/sentry/SentryBaseEvent, io/s
 	public fun getReplayStartTimestamp ()Ljava/util/Date;
 	public fun getReplayType ()Lio/sentry/SentryReplayEvent$ReplayType;
 	public fun getSegmentId ()I
+	public fun getSegmentNames ()Ljava/util/List;
 	public fun getTimestamp ()Ljava/util/Date;
 	public fun getTraceIds ()Ljava/util/List;
 	public fun getType ()Ljava/lang/String;
@@ -4036,6 +4039,7 @@ public final class io/sentry/SentryReplayEvent : io/sentry/SentryBaseEvent, io/s
 	public fun setReplayStartTimestamp (Ljava/util/Date;)V
 	public fun setReplayType (Lio/sentry/SentryReplayEvent$ReplayType;)V
 	public fun setSegmentId (I)V
+	public fun setSegmentNames (Ljava/util/List;)V
 	public fun setTimestamp (Ljava/util/Date;)V
 	public fun setTraceIds (Ljava/util/List;)V
 	public fun setType (Ljava/lang/String;)V
@@ -4056,6 +4060,7 @@ public final class io/sentry/SentryReplayEvent$JsonKeys {
 	public static final field REPLAY_START_TIMESTAMP Ljava/lang/String;
 	public static final field REPLAY_TYPE Ljava/lang/String;
 	public static final field SEGMENT_ID Ljava/lang/String;
+	public static final field SEGMENT_NAMES Ljava/lang/String;
 	public static final field TIMESTAMP Ljava/lang/String;
 	public static final field TRACE_IDS Ljava/lang/String;
 	public static final field TYPE Ljava/lang/String;
diff --git a/sentry/src/main/java/io/sentry/NoOpReplayController.java b/sentry/src/main/java/io/sentry/NoOpReplayController.java
index 2f6de9740d2..2b8a09cb1d9 100644
--- a/sentry/src/main/java/io/sentry/NoOpReplayController.java
+++ b/sentry/src/main/java/io/sentry/NoOpReplayController.java
@@ -60,4 +60,7 @@ public void disableDebugMaskingOverlay() {}
 
   @Override
   public void registerTraceId(@NotNull SentryId traceId) {}
+
+  @Override
+  public void registerSegmentName(@NotNull String segmentName) {}
 }
diff --git a/sentry/src/main/java/io/sentry/ReplayController.java b/sentry/src/main/java/io/sentry/ReplayController.java
index f4baba40c9d..2fb7b1c83a5 100644
--- a/sentry/src/main/java/io/sentry/ReplayController.java
+++ b/sentry/src/main/java/io/sentry/ReplayController.java
@@ -36,4 +36,7 @@ public interface ReplayController extends IReplayApi {
    * @param traceId the trace ID to associate with the current replay
    */
   void registerTraceId(@NotNull SentryId traceId);
+
+  /** Registers a segment name to be associated with the current replay segment. */
+  void registerSegmentName(@NotNull String segmentName);
 }
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index 4889d1629ce..a0ff98a9af7 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -1079,6 +1079,10 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
       if (trace != null) {
         options.getReplayController().registerTraceId(trace.getTraceId());
       }
+      final @Nullable String segmentName = transaction.getTransaction();
+      if (segmentName != null && !segmentName.isEmpty()) {
+        options.getReplayController().registerSegmentName(segmentName);
+      }
     }
 
     return sentryId;
diff --git a/sentry/src/main/java/io/sentry/SentryReplayEvent.java b/sentry/src/main/java/io/sentry/SentryReplayEvent.java
index 95623d2ff62..0ed9dbf72f3 100644
--- a/sentry/src/main/java/io/sentry/SentryReplayEvent.java
+++ b/sentry/src/main/java/io/sentry/SentryReplayEvent.java
@@ -49,6 +49,7 @@ public static final class Deserializer implements JsonDeserializer<ReplayType> {
   private @Nullable List<String> urls;
   private @Nullable List<String> errorIds;
   private @Nullable List<String> traceIds;
+  private @Nullable List<String> segmentNames;
   private @Nullable Map<String, Object> unknown;
 
   public SentryReplayEvent() {
@@ -58,6 +59,7 @@ public SentryReplayEvent() {
     this.replayType = ReplayType.SESSION;
     this.errorIds = new ArrayList<>();
     this.traceIds = new ArrayList<>();
+    this.segmentNames = new ArrayList<>();
     this.urls = new ArrayList<>();
     timestamp = DateUtils.getCurrentDateTime();
   }
@@ -142,6 +144,15 @@ public void setTraceIds(final @Nullable List<String> traceIds) {
     this.traceIds = traceIds;
   }
 
+  @Nullable
+  public List<String> getSegmentNames() {
+    return segmentNames;
+  }
+
+  public void setSegmentNames(final @Nullable List<String> segmentNames) {
+    this.segmentNames = segmentNames;
+  }
+
   @NotNull
   public ReplayType getReplayType() {
     return replayType;
@@ -162,12 +173,14 @@ public boolean equals(Object o) {
         && Objects.equals(replayId, that.replayId)
         && Objects.equals(urls, that.urls)
         && Objects.equals(errorIds, that.errorIds)
-        && Objects.equals(traceIds, that.traceIds);
+        && Objects.equals(traceIds, that.traceIds)
+        && Objects.equals(segmentNames, that.segmentNames);
   }
 
   @Override
   public int hashCode() {
-    return Objects.hash(type, replayType, replayId, segmentId, urls, errorIds, traceIds);
+    return Objects.hash(
+        type, replayType, replayId, segmentId, urls, errorIds, traceIds, segmentNames);
   }
 
   // region json
@@ -181,6 +194,7 @@ public static final class JsonKeys {
     public static final String URLS = "urls";
     public static final String ERROR_IDS = "error_ids";
     public static final String TRACE_IDS = "trace_ids";
+    public static final String SEGMENT_NAMES = "segment_names";
   }
 
   @Override
@@ -207,6 +221,9 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
     if (traceIds != null) {
       writer.name(JsonKeys.TRACE_IDS).value(logger, traceIds);
     }
+    if (segmentNames != null) {
+      writer.name(JsonKeys.SEGMENT_NAMES).value(logger, segmentNames);
+    }
 
     new SentryBaseEvent.Serializer().serialize(this, writer, logger);
 
@@ -250,6 +267,7 @@ public static final class Deserializer implements JsonDeserializer<SentryReplayE
       @Nullable List<String> urls = null;
       @Nullable List<String> errorIds = null;
       @Nullable List<String> traceIds = null;
+      @Nullable List<String> segmentNames = null;
 
       reader.beginObject();
       while (reader.peek() == JsonToken.NAME) {
@@ -282,6 +300,9 @@ public static final class Deserializer implements JsonDeserializer<SentryReplayE
           case JsonKeys.TRACE_IDS:
             traceIds = (List<String>) reader.nextObjectOrNull();
             break;
+          case JsonKeys.SEGMENT_NAMES:
+            segmentNames = (List<String>) reader.nextObjectOrNull();
+            break;
           default:
             if (!baseEventDeserializer.deserializeValue(replay, nextName, reader, logger)) {
               if (unknown == null) {
@@ -311,6 +332,7 @@ public static final class Deserializer implements JsonDeserializer<SentryReplayE
       replay.setUrls(urls);
       replay.setErrorIds(errorIds);
       replay.setTraceIds(traceIds);
+      replay.setSegmentNames(segmentNames);
       replay.setUnknown(unknown);
       return replay;
     }
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index fff05933d4e..5cfa4b6b619 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -2130,6 +2130,8 @@ class SentryClientTest {
         override fun registerTraceId(traceId: SentryId) {
           registeredTraceId = traceId
         }
+
+        override fun registerSegmentName(segmentName: String) {}
       }
     )
     val sut = fixture.getSut()
@@ -2139,6 +2141,24 @@ class SentryClientTest {
     assertEquals(sentryTracer.spanContext.traceId, registeredTraceId)
   }
 
+  @Test
+  fun `captureTransaction registers segment name with replay controller`() {
+    var registeredSegmentName: String? = null
+    fixture.sentryOptions.setReplayController(
+      object : ReplayController by NoOpReplayController.getInstance() {
+        override fun registerSegmentName(segmentName: String) {
+          registeredSegmentName = segmentName
+        }
+      }
+    )
+    val sut = fixture.getSut()
+    val sentryTracer =
+      SentryTracer(TransactionContext("CheckoutActivity", "ui.load"), fixture.scopes)
+    val transaction = SentryTransaction(sentryTracer)
+    sut.captureTransaction(transaction, sentryTracer.traceContext())
+    assertEquals("CheckoutActivity", registeredSegmentName)
+  }
+
   @Test
   fun `when exception type is ignored, capturing event does not send it`() {
     fixture.sentryOptions.addIgnoredExceptionForType(IllegalStateException::class.java)
diff --git a/sentry/src/test/java/io/sentry/protocol/SentryReplayEventSerializationTest.kt b/sentry/src/test/java/io/sentry/protocol/SentryReplayEventSerializationTest.kt
index 8c397b27fea..fabf2e03e93 100644
--- a/sentry/src/test/java/io/sentry/protocol/SentryReplayEventSerializationTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/SentryReplayEventSerializationTest.kt
@@ -26,6 +26,7 @@ class SentryReplayEventSerializationTest {
         urls = listOf("ScreenOne")
         errorIds = listOf("ab3a347a4cc14fd4b4cf1dc56b670c5b")
         traceIds = listOf("340cfef948204549ac07c3b353c81c50")
+        segmentNames = listOf("CheckoutActivity")
         SentryBaseEventSerializationTest.Fixture().update(this)
         // irrelevant for replay
         serverName = null
diff --git a/sentry/src/test/resources/json/sentry_replay_event.json b/sentry/src/test/resources/json/sentry_replay_event.json
index eb2503edc8e..29bcca85aea 100644
--- a/sentry/src/test/resources/json/sentry_replay_event.json
+++ b/sentry/src/test/resources/json/sentry_replay_event.json
@@ -17,6 +17,10 @@
     [
       "340cfef948204549ac07c3b353c81c50"
     ],
+    "segment_names":
+    [
+      "CheckoutActivity"
+    ],
     "event_id": "afcb46b1140ade5187c4bbb5daa804df",
     "contexts":
     {

From 0b8ad150264aaa0ccc18c3e29926277cec015007 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 16 Jul 2026 11:12:01 +0200
Subject: [PATCH 298/391] feat(samples): Enable Sentry Logs in the Android
 sample app (#5766)

The Android sample already emits structured logs via Sentry.logger() in
MainActivity.onCreate, but they were silently dropped because the Logs
feature is disabled by default. Enable it through the manifest so the
sample demonstrates the logging feature out of the box.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../sentry-samples-android/src/main/AndroidManifest.xml      | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 61f4df5b8d9..9a079a26632 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -130,6 +130,11 @@
       android:name="io.sentry.debug"
       android:value="${sentryDebug}" />
 
+    <!--    how to enable Sentry Logs (Sentry.logger() calls are dropped unless this is on)-->
+    <meta-data
+      android:name="io.sentry.logs.enabled"
+      android:value="true" />
+
     <!--    how to disable verbose logging of the session replay feature-->
     <meta-data
       android:name="io.sentry.session-replay.debug"

From 955d0fc81f48c488ad978dc454ca17ce23fca2c4 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 16 Jul 2026 11:12:16 +0200
Subject: [PATCH 299/391] fix(samples): Use float literal for session-replay
 sample rate (#5764)

The Android sample manifest set io.sentry.session-replay.session-sample-rate
to the integer literal "1", which aapt stores as an int. ManifestMetadataReader
reads it via Bundle.getFloat, which does not coerce an int-typed value and logs
a framework warning before falling back to getInt on startup. Using the float
literal "1.0" stores it as a float so getFloat succeeds and no warning is logged.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../sentry-samples-android/src/main/AndroidManifest.xml         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 9a079a26632..79150b51c98 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -271,7 +271,7 @@
       android:value="canvas" />
     <meta-data
       android:name="io.sentry.session-replay.session-sample-rate"
-      android:value="1" />
+      android:value="1.0" />
     <meta-data
       android:name="io.sentry.session-replay.mask-all-text"
       android:value="true" />

From 6424ca98d72b1fc02e1109d1813b50258035bc34 Mon Sep 17 00:00:00 2001
From: Lukas Bloder <lukas.bloder@gmail.com>
Date: Thu, 16 Jul 2026 11:18:04 +0200
Subject: [PATCH 300/391] Use the same method to get url in all spring filters
 (#5656)

* use the same method to get url in all spring filters

* remove unnecessary system out message in DatabaseUtils

* spotless

* extract target url to match against tracePropagationTargets

* inject headers if url cannot be extracted to be in line with other integrations

* Format code

* verify host matches requestingHost before returning authentication

* format

* remove applyToSpan to not introduce unexpected behaviour in a minor release

* Changelog

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
Co-authored-by: Roman Zavarnitsyn <rom4ek93@gmail.com>
---
 CHANGELOG.md                                  |  4 +
 .../java/io/sentry/jdbc/DatabaseUtils.java    |  1 -
 .../build.gradle.kts                          |  2 +-
 .../otlp/OpenTelemetryOtlpPropagator.java     | 55 +++++++++++
 .../test/kotlin/OtelSentryPropagatorTest.kt   | 92 +++++++++++++++++++
 .../SentrySpanClientWebRequestFilter.java     |  4 +-
 .../mvc/SentrySpringIntegrationTest.kt        |  5 +-
 .../SentrySpanClientWebRequestFilter.java     |  4 +-
 .../mvc/SentrySpringIntegrationTest.kt        |  5 +-
 .../io/sentry/transport/HttpConnection.java   |  7 +-
 .../sentry/transport/ProxyAuthenticator.java  |  7 +-
 .../io/sentry/transport/HttpConnectionTest.kt | 11 +++
 .../transport/ProxyAuthenticatorTest.kt       | 62 +++++++++++++
 13 files changed, 246 insertions(+), 13 deletions(-)
 create mode 100644 sentry/src/test/java/io/sentry/transport/ProxyAuthenticatorTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cdc3e33452b..ff35eabe03a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -36,6 +36,10 @@
 - Session Replay: Fix error-to-replay linkage in `buffer` mode ([#5754](https://github.com/getsentry/sentry-java/pull/5754))
 - Prevent logs and metrics from remaining queued after a flush scheduling race ([#5756](https://github.com/getsentry/sentry-java/pull/5756))
 - Fix main thread identification for tombstone (native crash) events ([#5742](https://github.com/getsentry/sentry-java/pull/5742))
+- Prevent malformed JDBC URLs, which may contain credentials, from being printed to stdout ([#5656](https://github.com/getsentry/sentry-java/pull/5656))
+- Restrict JVM-global proxy authentication credentials to challenges from the configured proxy host ([#5656](https://github.com/getsentry/sentry-java/pull/5656))
+- Sanitize Spring 7 and Spring Jakarta WebClient span descriptions to prevent embedded URL credentials from being sent to Sentry ([#5656](https://github.com/getsentry/sentry-java/pull/5656))
+- Respect `tracePropagationTargets` when injecting Sentry tracing headers through the OpenTelemetry OTLP propagator ([#5656](https://github.com/getsentry/sentry-java/pull/5656))
 
 ### Performance
 
diff --git a/sentry-jdbc/src/main/java/io/sentry/jdbc/DatabaseUtils.java b/sentry-jdbc/src/main/java/io/sentry/jdbc/DatabaseUtils.java
index 6879723ebf9..4583dc9e6c1 100644
--- a/sentry-jdbc/src/main/java/io/sentry/jdbc/DatabaseUtils.java
+++ b/sentry-jdbc/src/main/java/io/sentry/jdbc/DatabaseUtils.java
@@ -131,7 +131,6 @@ public static DatabaseDetails parse(final @Nullable String databaseConnectionUrl
       String pathWithoutProperties = StringUtils.substringBefore(path, ";");
       return new DatabaseDetails(dbSystem, pathWithoutProperties);
     } catch (Throwable t) {
-      System.out.println(t.getMessage());
       // ignore
     }
     return new DatabaseDetails(dbSystem, null);
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
index 1792c852dc3..ec240c681ae 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/build.gradle.kts
@@ -21,7 +21,7 @@ dependencies {
   api(libs.otel.extension.autoconfigure)
   api(libs.otel.exporter.otlp)
   compileOnly(libs.otel.extension.autoconfigure.spi)
-  //  compileOnly(libs.otel.semconv)
+  implementation(libs.otel.semconv)
   //  compileOnly(libs.otel.semconv.incubating)
 
   compileOnly(libs.jetbrains.annotations)
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java
index a4249b27ec0..4cdf1b0ed09 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/main/java/io/sentry/opentelemetry/otlp/OpenTelemetryOtlpPropagator.java
@@ -2,6 +2,7 @@
 
 import static io.sentry.SentryTraceHeader.SENTRY_TRACE_HEADER;
 
+import io.opentelemetry.api.common.Attributes;
 import io.opentelemetry.api.trace.Span;
 import io.opentelemetry.api.trace.SpanContext;
 import io.opentelemetry.api.trace.TraceFlags;
@@ -11,14 +12,20 @@
 import io.opentelemetry.context.propagation.TextMapGetter;
 import io.opentelemetry.context.propagation.TextMapPropagator;
 import io.opentelemetry.context.propagation.TextMapSetter;
+import io.opentelemetry.sdk.trace.ReadableSpan;
+import io.opentelemetry.semconv.ServerAttributes;
+import io.opentelemetry.semconv.UrlAttributes;
 import io.sentry.Baggage;
 import io.sentry.BaggageHeader;
 import io.sentry.IScopes;
 import io.sentry.ScopesAdapter;
 import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
 import io.sentry.SentryTraceHeader;
 import io.sentry.exception.InvalidSentryTraceHeaderException;
+import io.sentry.util.PropagationTargetsUtils;
 import io.sentry.util.TracingUtils;
+import java.net.URL;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
@@ -61,6 +68,10 @@ public <C> void inject(final Context context, final C carrier, final TextMapSett
       return;
     }
 
+    if (!shouldInjectTracingHeaders(otelSpan)) {
+      return;
+    }
+
     setter.set(
         carrier,
         SENTRY_TRACE_HEADER,
@@ -76,6 +87,50 @@ public <C> void inject(final Context context, final C carrier, final TextMapSett
     }
   }
 
+  private boolean shouldInjectTracingHeaders(final @NotNull Span otelSpan) {
+    final @NotNull SentryOptions options = scopes.getOptions();
+    final @Nullable String url = extractUrl(otelSpan, options);
+
+    return url == null
+        || PropagationTargetsUtils.contain(options.getTracePropagationTargets(), url);
+  }
+
+  private @Nullable String extractUrl(
+      final @NotNull Span otelSpan, final @NotNull SentryOptions options) {
+    if (!(otelSpan instanceof ReadableSpan)) {
+      return null;
+    }
+
+    final @NotNull Attributes attributes = ((ReadableSpan) otelSpan).getAttributes();
+    final @Nullable String urlFull = attributes.get(UrlAttributes.URL_FULL);
+    if (urlFull != null) {
+      return urlFull;
+    }
+
+    final @Nullable String scheme = attributes.get(UrlAttributes.URL_SCHEME);
+    final @Nullable String serverAddress = attributes.get(ServerAttributes.SERVER_ADDRESS);
+    final @Nullable Long serverPort = attributes.get(ServerAttributes.SERVER_PORT);
+    final @Nullable String path = attributes.get(UrlAttributes.URL_PATH);
+
+    if (scheme == null || serverAddress == null) {
+      return null;
+    }
+
+    try {
+      final @NotNull String pathToUse = path == null ? "" : path;
+      if (serverPort == null) {
+        return new URL(scheme, serverAddress, pathToUse).toString();
+      } else {
+        return new URL(scheme, serverAddress, serverPort.intValue(), pathToUse).toString();
+      }
+    } catch (Throwable t) {
+      options
+          .getLogger()
+          .log(SentryLevel.WARNING, "Unable to combine URL span attributes into one.", t);
+      return null;
+    }
+  }
+
   @Override
   public <C> Context extract(
       final Context context, final C carrier, final TextMapGetter<C> getter) {
diff --git a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt
index 1d5d56c5bff..afa728c7ff0 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt
+++ b/sentry-opentelemetry/sentry-opentelemetry-otlp/src/test/kotlin/OtelSentryPropagatorTest.kt
@@ -7,6 +7,7 @@ import io.opentelemetry.api.trace.TraceState
 import io.opentelemetry.context.Context
 import io.opentelemetry.context.propagation.TextMapGetter
 import io.opentelemetry.context.propagation.TextMapSetter
+import io.opentelemetry.sdk.trace.SdkTracerProvider
 import io.sentry.Baggage
 import io.sentry.Sentry
 import kotlin.test.AfterTest
@@ -171,6 +172,97 @@ class OpenTelemetryOtlpPropagatorTest {
     )
   }
 
+  @Test
+  fun `injects headers if URL in span attributes matches tracePropagationTargets`() {
+    Sentry.init { options ->
+      options.dsn = "https://key@sentry.io/proj"
+      options.setTracePropagationTargets(listOf("sentry.io"))
+    }
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier = mutableMapOf<String, String>()
+    val tracerProvider = SdkTracerProvider.builder().build()
+    val otelSpan =
+      tracerProvider
+        .get("test")
+        .spanBuilder("test")
+        .setAttribute("url.full", "https://sentry.io/api/0/")
+        .startSpan()
+    val baggage =
+      Baggage.fromHeader(
+        "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d"
+      )
+
+    try {
+      val context =
+        Context.root().with(otelSpan).with(OpenTelemetryOtlpPropagator.SENTRY_BAGGAGE_KEY, baggage)
+
+      propagator.inject(context, carrier, MapSetter())
+    } finally {
+      otelSpan.end()
+      tracerProvider.shutdown()
+    }
+
+    assertEquals(
+      "${otelSpan.spanContext.traceId}-${otelSpan.spanContext.spanId}-1",
+      carrier["sentry-trace"],
+    )
+    assertEquals(
+      "sentry-environment=production,sentry-public_key=502f25099c204a2fbf4cb16edc5975d1,sentry-sample_rand=0.456789,sentry-sample_rate=0.5,sentry-sampled=true,sentry-trace_id=df71f5972f754b4c85af13ff5c07017d",
+      carrier["baggage"],
+    )
+  }
+
+  @Test
+  fun `does not inject headers if URL in span attributes does not match tracePropagationTargets`() {
+    Sentry.init { options ->
+      options.dsn = "https://key@sentry.io/proj"
+      options.setTracePropagationTargets(listOf("github.com"))
+    }
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier = mutableMapOf<String, String>()
+    val tracerProvider = SdkTracerProvider.builder().build()
+    val otelSpan =
+      tracerProvider
+        .get("test")
+        .spanBuilder("test")
+        .setAttribute("url.full", "https://sentry.io/api/0/")
+        .startSpan()
+
+    try {
+      propagator.inject(Context.root().with(otelSpan), carrier, MapSetter())
+    } finally {
+      otelSpan.end()
+      tracerProvider.shutdown()
+    }
+
+    assertNull(carrier["sentry-trace"])
+    assertNull(carrier["baggage"])
+  }
+
+  @Test
+  fun `injects headers if tracePropagationTargets is restricted and URL is unavailable`() {
+    Sentry.init { options ->
+      options.dsn = "https://key@sentry.io/proj"
+      options.setTracePropagationTargets(listOf("sentry.io"))
+    }
+    val propagator = OpenTelemetryOtlpPropagator()
+    val carrier = mutableMapOf<String, String>()
+
+    val otelSpanContext =
+      SpanContext.create(
+        "f9118105af4a2d42b4124532cd1065ff",
+        "424cffc8f94feeee",
+        TraceFlags.getSampled(),
+        TraceState.getDefault(),
+      )
+    val otelSpan = Span.wrap(otelSpanContext)
+
+    propagator.inject(Context.root().with(otelSpan), carrier, MapSetter())
+
+    assertEquals("f9118105af4a2d42b4124532cd1065ff-424cffc8f94feeee-1", carrier["sentry-trace"])
+    assertNull(carrier["baggage"])
+  }
+
   @Test
   fun `does not inject headers when no span in context`() {
     val propagator = OpenTelemetryOtlpPropagator()
diff --git a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentrySpanClientWebRequestFilter.java b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentrySpanClientWebRequestFilter.java
index 6726302a83e..942cda241b7 100644
--- a/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentrySpanClientWebRequestFilter.java
+++ b/sentry-spring-7/src/main/java/io/sentry/spring7/tracing/SentrySpanClientWebRequestFilter.java
@@ -15,6 +15,7 @@
 import io.sentry.util.Objects;
 import io.sentry.util.SpanUtils;
 import io.sentry.util.TracingUtils;
+import io.sentry.util.UrlUtils;
 import java.util.Locale;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -45,8 +46,9 @@ public SentrySpanClientWebRequestFilter(final @NotNull IScopes scopes) {
     final @NotNull SpanOptions spanOptions = new SpanOptions();
     spanOptions.setOrigin(TRACE_ORIGIN);
     final ISpan span = activeSpan.startChild("http.client", null, spanOptions);
+    final @NotNull UrlUtils.UrlDetails urlDetails = UrlUtils.parse(request.url().toString());
     final @NotNull String method = request.method().name();
-    span.setDescription(method + " " + request.url());
+    span.setDescription(method + " " + urlDetails.getUrlOrFallback());
     span.setData(SpanDataConvention.HTTP_METHOD_KEY, method.toUpperCase(Locale.ROOT));
 
     final @NotNull ClientRequest modifiedRequest = maybeAddTracingHeaders(request, span);
diff --git a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/mvc/SentrySpringIntegrationTest.kt b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/mvc/SentrySpringIntegrationTest.kt
index 4b7e806730f..36e6af289fd 100644
--- a/sentry-spring-7/src/test/kotlin/io/sentry/spring7/mvc/SentrySpringIntegrationTest.kt
+++ b/sentry-spring-7/src/test/kotlin/io/sentry/spring7/mvc/SentrySpringIntegrationTest.kt
@@ -376,7 +376,8 @@ class SentrySpringIntegrationTest {
             assertThat(transaction.spans).hasSize(1)
             val span = transaction.spans.first()
             assertThat(span.op).isEqualTo("http.client")
-            assertThat(span.description).isEqualTo("GET http://localhost:$port/hello")
+            assertThat(span.description)
+              .isEqualTo("GET http://[Filtered]:[Filtered]@localhost:$port/hello")
             assertThat(span.data?.get(SpanDataConvention.HTTP_STATUS_CODE_KEY)).isEqualTo(200)
             assertThat(span.status).isEqualTo(SpanStatus.OK)
           },
@@ -519,7 +520,7 @@ class HelloController(private val webClient: WebClient, private val env: Environ
   fun webClient(): String? {
     return webClient
       .get()
-      .uri("http://localhost:${env.getProperty("local.server.port")}/hello")
+      .uri("http://user:password@localhost:${env.getProperty("local.server.port")}/hello")
       .retrieve()
       .bodyToMono(String::class.java)
       .block()
diff --git a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentrySpanClientWebRequestFilter.java b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentrySpanClientWebRequestFilter.java
index 1189532c0c4..ec29b9c68a3 100644
--- a/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentrySpanClientWebRequestFilter.java
+++ b/sentry-spring-jakarta/src/main/java/io/sentry/spring/jakarta/tracing/SentrySpanClientWebRequestFilter.java
@@ -15,6 +15,7 @@
 import io.sentry.util.Objects;
 import io.sentry.util.SpanUtils;
 import io.sentry.util.TracingUtils;
+import io.sentry.util.UrlUtils;
 import java.util.Locale;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -45,8 +46,9 @@ public SentrySpanClientWebRequestFilter(final @NotNull IScopes scopes) {
     final @NotNull SpanOptions spanOptions = new SpanOptions();
     spanOptions.setOrigin(TRACE_ORIGIN);
     final ISpan span = activeSpan.startChild("http.client", null, spanOptions);
+    final @NotNull UrlUtils.UrlDetails urlDetails = UrlUtils.parse(request.url().toString());
     final @NotNull String method = request.method().name();
-    span.setDescription(method + " " + request.url());
+    span.setDescription(method + " " + urlDetails.getUrlOrFallback());
     span.setData(SpanDataConvention.HTTP_METHOD_KEY, method.toUpperCase(Locale.ROOT));
 
     final @NotNull ClientRequest modifiedRequest = maybeAddTracingHeaders(request, span);
diff --git a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/mvc/SentrySpringIntegrationTest.kt b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/mvc/SentrySpringIntegrationTest.kt
index 6d399323f5f..f1837a08c1f 100644
--- a/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/mvc/SentrySpringIntegrationTest.kt
+++ b/sentry-spring-jakarta/src/test/kotlin/io/sentry/spring/jakarta/mvc/SentrySpringIntegrationTest.kt
@@ -374,7 +374,8 @@ class SentrySpringIntegrationTest {
             assertThat(transaction.spans).hasSize(1)
             val span = transaction.spans.first()
             assertThat(span.op).isEqualTo("http.client")
-            assertThat(span.description).isEqualTo("GET http://localhost:$port/hello")
+            assertThat(span.description)
+              .isEqualTo("GET http://[Filtered]:[Filtered]@localhost:$port/hello")
             assertThat(span.data?.get(SpanDataConvention.HTTP_STATUS_CODE_KEY)).isEqualTo(200)
             assertThat(span.status).isEqualTo(SpanStatus.OK)
           },
@@ -517,7 +518,7 @@ class HelloController(private val webClient: WebClient, private val env: Environ
   fun webClient(): String? {
     return webClient
       .get()
-      .uri("http://localhost:${env.getProperty("local.server.port")}/hello")
+      .uri("http://user:password@localhost:${env.getProperty("local.server.port")}/hello")
       .retrieve()
       .bodyToMono(String::class.java)
       .block()
diff --git a/sentry/src/main/java/io/sentry/transport/HttpConnection.java b/sentry/src/main/java/io/sentry/transport/HttpConnection.java
index 71c3ebb15b2..e7935e76cf3 100644
--- a/sentry/src/main/java/io/sentry/transport/HttpConnection.java
+++ b/sentry/src/main/java/io/sentry/transport/HttpConnection.java
@@ -64,9 +64,10 @@ public HttpConnection(
     if (proxy != null && options.getProxy() != null) {
       final String proxyUser = options.getProxy().getUser();
       final String proxyPassword = options.getProxy().getPass();
-
-      if (proxyUser != null && proxyPassword != null) {
-        authenticatorWrapper.setDefault(new ProxyAuthenticator(proxyUser, proxyPassword));
+      final String proxyHost = options.getProxy().getHost();
+      if (proxyUser != null && proxyPassword != null && proxyHost != null) {
+        authenticatorWrapper.setDefault(
+            new ProxyAuthenticator(proxyUser, proxyPassword, proxyHost));
       }
     }
   }
diff --git a/sentry/src/main/java/io/sentry/transport/ProxyAuthenticator.java b/sentry/src/main/java/io/sentry/transport/ProxyAuthenticator.java
index 7aad9967f18..74b63566b37 100644
--- a/sentry/src/main/java/io/sentry/transport/ProxyAuthenticator.java
+++ b/sentry/src/main/java/io/sentry/transport/ProxyAuthenticator.java
@@ -9,6 +9,7 @@
 final class ProxyAuthenticator extends Authenticator {
   private final @NotNull String user;
   private final @NotNull String password;
+  private final @NotNull String proxyHost;
 
   /**
    * Proxy authenticator.
@@ -16,14 +17,16 @@ final class ProxyAuthenticator extends Authenticator {
    * @param user proxy username
    * @param password proxy password
    */
-  ProxyAuthenticator(final @NotNull String user, final @NotNull String password) {
+  ProxyAuthenticator(
+      final @NotNull String user, final @NotNull String password, final @NotNull String proxyHost) {
     this.user = Objects.requireNonNull(user, "user is required");
     this.password = Objects.requireNonNull(password, "password is required");
+    this.proxyHost = Objects.requireNonNull(proxyHost, "proxyHost is required");
   }
 
   @Override
   protected @Nullable PasswordAuthentication getPasswordAuthentication() {
-    if (getRequestorType() == RequestorType.PROXY) {
+    if (getRequestorType() == RequestorType.PROXY && proxyHost.equals(getRequestingHost())) {
       return new PasswordAuthentication(user, password.toCharArray());
     }
     return null;
diff --git a/sentry/src/test/java/io/sentry/transport/HttpConnectionTest.kt b/sentry/src/test/java/io/sentry/transport/HttpConnectionTest.kt
index 2a856ab5800..4c17c71fecc 100644
--- a/sentry/src/test/java/io/sentry/transport/HttpConnectionTest.kt
+++ b/sentry/src/test/java/io/sentry/transport/HttpConnectionTest.kt
@@ -259,6 +259,17 @@ class HttpConnectionTest {
     assertEquals(Type.SOCKS, transport.proxy!!.type())
   }
 
+  @Test
+  fun `When Proxy username and password are given but host is missing, authenticator is not set`() {
+    fixture.proxy = Proxy(null, "8090", "some-user", "some-password")
+    val transport = fixture.getSUT()
+
+    transport.send(createEnvelope())
+
+    assertNull(transport.proxy)
+    verify(fixture.authenticatorWrapper, never()).setDefault(any())
+  }
+
   @Test
   fun `sets common headers and on http connection`() {
     val transport = fixture.getSUT()
diff --git a/sentry/src/test/java/io/sentry/transport/ProxyAuthenticatorTest.kt b/sentry/src/test/java/io/sentry/transport/ProxyAuthenticatorTest.kt
new file mode 100644
index 00000000000..c3af7da226d
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/transport/ProxyAuthenticatorTest.kt
@@ -0,0 +1,62 @@
+package io.sentry.transport
+
+import java.net.Authenticator
+import java.net.Authenticator.RequestorType
+import java.net.PasswordAuthentication
+import java.net.URL
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class ProxyAuthenticatorTest {
+  @BeforeTest
+  @AfterTest
+  fun reset() {
+    Authenticator.setDefault(null)
+  }
+
+  @Test
+  fun `returns authentication when proxy request host matches proxy host`() {
+    Authenticator.setDefault(ProxyAuthenticator("some-user", "some-password", "proxy.example.com"))
+
+    val authentication = requestPasswordAuthentication("proxy.example.com", RequestorType.PROXY)
+
+    assertEquals("some-user", authentication!!.userName)
+    assertEquals("some-password", String(authentication.password))
+  }
+
+  @Test
+  fun `returns null when requestor type is not proxy`() {
+    Authenticator.setDefault(ProxyAuthenticator("some-user", "some-password", "proxy.example.com"))
+
+    val authentication = requestPasswordAuthentication("proxy.example.com", RequestorType.SERVER)
+
+    assertNull(authentication)
+  }
+
+  @Test
+  fun `returns null when proxy request host does not match proxy host`() {
+    Authenticator.setDefault(ProxyAuthenticator("some-user", "some-password", "proxy.example.com"))
+
+    val authentication = requestPasswordAuthentication("other.example.com", RequestorType.PROXY)
+
+    assertNull(authentication)
+  }
+
+  private fun requestPasswordAuthentication(
+    host: String,
+    requestorType: RequestorType,
+  ): PasswordAuthentication? =
+    Authenticator.requestPasswordAuthentication(
+      host,
+      null,
+      8080,
+      "https",
+      "prompt",
+      "basic",
+      URL("https://sentry.io"),
+      requestorType,
+    )
+}

From 53ff4715b5f6b631079c7437461a2be0913710f6 Mon Sep 17 00:00:00 2001
From: romtsn <4999776+romtsn@users.noreply.github.com>
Date: Thu, 16 Jul 2026 09:19:39 +0000
Subject: [PATCH 301/391] release: 8.49.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ff35eabe03a..c57c75fe6a7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.49.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 91122c1141f..aa5a7b1e28d 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -13,7 +13,7 @@ android.useAndroidX=true
 android.experimental.lint.version=8.13.1
 
 # Release information
-versionName=8.48.0
+versionName=8.49.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 455eb6ed9adac5768a16757d85c99fec68caac67 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 16 Jul 2026 17:02:14 +0200
Subject: [PATCH 302/391] ci: Use non-deprecated sentry-cli snapshots upload
 command (#5774)

The `sentry-cli build snapshots` command is deprecated in favor of
`sentry-cli snapshots upload`. Rename both usages in CI so the upload
steps stop emitting deprecation warnings and keep working once the old
command is removed.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/workflows/build.yml                | 2 +-
 .github/workflows/integration-tests-ui.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index e396ef97175..a11da2987dd 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -52,7 +52,7 @@ jobs:
         # Skip on PRs from forks, which don't have access to the upload secret
         if: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository }}
         run: |
-          sentry-cli build snapshots ./sentry-android-core/build/test-snapshots \
+          sentry-cli snapshots upload ./sentry-android-core/build/test-snapshots \
             --app-id sentry-android-core
         env:
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index ed3a72ce7fc..a1f02d8512d 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -86,7 +86,7 @@ jobs:
           if [ ${#pngs[@]} -gt 0 ]; then
             mkdir -p replay-snapshots
             cp "${pngs[@]}" replay-snapshots/
-            sentry-cli build snapshots ./replay-snapshots \
+            sentry-cli snapshots upload ./replay-snapshots \
               --app-id sentry-android-replay
           else
             echo "No replay snapshot files found, skipping upload"

From 031ec336fb2ecc9c057d02fd60d4979eee095824 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Fri, 17 Jul 2026 12:43:31 +0200
Subject: [PATCH 303/391] fix(android): Backfill pre-init ANR and native crash
 metadata (#5762)

* fix(android): Backfill exit options when app is unchanged

Use current options when persisted values are missing and the app has not been updated since the exit. Avoid attributing historical crashes to a newer app version.

* changelog

* fix(android): Backfill app context for historical exits

Populate app version and build for historical ANR and native crash events when the current package metadata is safe to use.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Limit historical app metadata backfill

Backfill only app version and build for historical exits. Avoid attaching current localized app names, identifiers, or split APK state to older events.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Reject unknown exit timestamps

Do not use current SDK options when an exit timestamp is unavailable because an intervening app update cannot be ruled out.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Validate persisted options cache generation

Persist the app update timestamp after writing the options snapshot. Trust cached release, environment, and dist only when the marker identifies the current app installation, preserving launch-specific values without leaking stale metadata across app updates.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Validate launch-specific cached options

Apply the app-generation marker when selecting option tags and the replay-on-error sample rate. Preserve values from the crashed launch within one app version while rejecting stale values after an update.

Co-Authored-By: Codex <noreply@openai.com>

* docs(android): Explain options cache marker ordering

Document why the generation observer uses its release callback only after the options cache has been fully persisted.

Co-Authored-By: Codex <noreply@openai.com>

* fix(android): Validate exit option cache sources

Reject option caches created after an exit and keep immutable build metadata aligned with the event's app generation. This prevents intermediate releases and stale ProGuard or SDK metadata from being attached to historical exits.

Co-Authored-By: Codex <noreply@openai.com>

* style(android): Annotate nullable app context

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* docs(android): Explain options cache generation observer

Clarify why the observer is ordered after option persistence and update the changelog to describe the generation-aware behavior.

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* docs(android): Add cache generation example

Document the same-build, account-specific options scenario that requires preferring a matching persisted snapshot.

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* ref(android): Reuse cache utilities for generation marker

Expose cache serialization helpers as internal API and use them for the Android options cache generation marker.

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* docs(android): Explain exit option selection

Document how launch options, build metadata, and cache generations are selected for application exit events.

Co-Authored-By: OpenAI Codex <noreply@openai.com>

* docs: Move changelog entry to Unreleased

Keep PR #5762 out of the already released 8.49.0 section.

Co-Authored-By: Codex <noreply@openai.com>

---------

Co-authored-by: Codex <noreply@openai.com>
---
 CHANGELOG.md                                  |   6 +
 .../core/AndroidOptionsInitializer.java       |   5 +
 .../ApplicationExitInfoEventProcessor.java    | 222 ++++++++++++-----
 ...sistingOptionsCacheGenerationObserver.java |  88 +++++++
 .../core/AndroidOptionsInitializerTest.kt     |  15 ++
 .../ApplicationExitInfoEventProcessorTest.kt  | 234 +++++++++++++++++-
 sentry/api/sentry.api                         |   5 +
 .../main/java/io/sentry/cache/CacheUtils.java |  10 +-
 8 files changed, 522 insertions(+), 63 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/PersistingOptionsCacheGenerationObserver.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c57c75fe6a7..44231ff4eed 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Backfill release, environment, distribution, tags, and app version/build—and use the matching replay-on-error sample rate—for `ApplicationExitInfo` ANR and native crash events captured before SDK initialization, without reusing options cached by a later app update ([#5762](https://github.com/getsentry/sentry-java/pull/5762))
+
 ## 8.49.0
 
 ### Features
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 9cc5cb3df0f..434dfc73d3e 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -182,6 +182,11 @@ static void initializeIntegrationsAndProcessors(
     if (options.getCacheDirPath() != null) {
       options.addScopeObserver(new PersistingScopeObserver(options));
       options.addOptionsObserver(new PersistingOptionsObserver(options));
+      final PackageInfo packageInfo = ContextUtils.getPackageInfo(context, buildInfoProvider);
+      if (packageInfo != null && packageInfo.lastUpdateTime > 0) {
+        options.addOptionsObserver(
+            new PersistingOptionsCacheGenerationObserver(options, packageInfo.lastUpdateTime));
+      }
     }
 
     options.addEventProcessor(new DeduplicateMultithreadedEventProcessor(options));
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
index 2eca0e68b5b..f175db90488 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
@@ -51,6 +51,7 @@
 import io.sentry.exception.ExceptionMechanismException;
 import io.sentry.hints.AbnormalExit;
 import io.sentry.hints.Backfillable;
+import io.sentry.hints.NativeCrashExit;
 import io.sentry.protocol.App;
 import io.sentry.protocol.Contexts;
 import io.sentry.protocol.DebugImage;
@@ -161,7 +162,13 @@ public ApplicationExitInfoEventProcessor(
     mergeOS(event);
     setDevice(event);
 
+    final OptionsSource optionsSource = getOptionsSource(backfillable);
+
     if (!backfillable.shouldEnrich()) {
+      setRelease(event, optionsSource);
+      setEnvironment(event, optionsSource);
+      setDist(event, optionsSource);
+      setAppVersionAndBuild(event);
       options
           .getLogger()
           .log(
@@ -170,9 +177,9 @@ public ApplicationExitInfoEventProcessor(
       return event;
     }
 
-    backfillScope(event);
+    backfillScope(event, optionsSource);
 
-    backfillOptions(event);
+    backfillOptions(event, optionsSource);
 
     setStaticValues(event);
 
@@ -184,7 +191,8 @@ public ApplicationExitInfoEventProcessor(
   }
 
   // region scope persisted values
-  private void backfillScope(final @NotNull SentryEvent event) {
+  private void backfillScope(
+      final @NotNull SentryEvent event, final @NotNull OptionsSource optionsSource) {
     setRequest(event);
     setUser(event);
     setScopeTags(event);
@@ -195,19 +203,25 @@ private void backfillScope(final @NotNull SentryEvent event) {
     setFingerprints(event);
     setLevel(event);
     setTrace(event);
-    setReplayId(event);
+    setReplayId(event, optionsSource);
   }
 
-  private boolean sampleReplay(final @NotNull SentryEvent event) {
+  private boolean sampleReplay(
+      final @NotNull SentryEvent event, final @NotNull OptionsSource optionsSource) {
+    final @Nullable Double currentSampleRate = options.getSessionReplay().getOnErrorSampleRate();
     final @Nullable String replayErrorSampleRate =
-        PersistingOptionsObserver.read(options, REPLAY_ERROR_SAMPLE_RATE_FILENAME, String.class);
+        getLaunchOption(
+            REPLAY_ERROR_SAMPLE_RATE_FILENAME,
+            String.class,
+            currentSampleRate == null ? null : currentSampleRate.toString(),
+            optionsSource);
 
     if (replayErrorSampleRate == null) {
       return false;
     }
 
     try {
-      // we have to sample here with the old sample rate, because it may change between app launches
+      // Sample with the rate from the relevant launch because it may change between launches.
       final double replayErrorSampleRateDouble = Double.parseDouble(replayErrorSampleRate);
       if (replayErrorSampleRateDouble < SentryRandom.current().nextDouble()) {
         options
@@ -226,7 +240,8 @@ private boolean sampleReplay(final @NotNull SentryEvent event) {
     return true;
   }
 
-  private void setReplayId(final @NotNull SentryEvent event) {
+  private void setReplayId(
+      final @NotNull SentryEvent event, final @NotNull OptionsSource optionsSource) {
     @Nullable String persistedReplayId = readFromDisk(options, REPLAY_FILENAME, String.class);
     @Nullable String cacheDirPath = options.getCacheDirPath();
     if (cacheDirPath == null) {
@@ -234,7 +249,7 @@ private void setReplayId(final @NotNull SentryEvent event) {
     }
     final @NotNull File replayFolder = new File(cacheDirPath, "replay_" + persistedReplayId);
     if (!replayFolder.exists()) {
-      if (!sampleReplay(event)) {
+      if (!sampleReplay(event, optionsSource)) {
         return;
       }
       // if the replay folder does not exist (e.g. running in buffer mode), we need to find the
@@ -393,14 +408,15 @@ private void setRequest(final @NotNull SentryBaseEvent event) {
   // endregion
 
   // region options persisted values
-  private void backfillOptions(final @NotNull SentryEvent event) {
-    setRelease(event);
-    setEnvironment(event);
-    setDist(event);
-    setDebugMeta(event);
-    setSdk(event);
+  private void backfillOptions(
+      final @NotNull SentryEvent event, final @NotNull OptionsSource optionsSource) {
+    setRelease(event, optionsSource);
+    setEnvironment(event, optionsSource);
+    setDist(event, optionsSource);
+    setDebugMeta(event, optionsSource);
+    setSdk(event, optionsSource);
     setApp(event);
-    setOptionsTags(event);
+    setOptionsTags(event, optionsSource);
   }
 
   private void setApp(final @NotNull SentryBaseEvent event) {
@@ -415,25 +431,6 @@ private void setApp(final @NotNull SentryBaseEvent event) {
       app.setAppIdentifier(packageInfo.packageName);
     }
 
-    // backfill versionName and versionCode from the persisted release string
-    final String release =
-        event.getRelease() != null
-            ? event.getRelease()
-            : PersistingOptionsObserver.read(options, RELEASE_FILENAME, String.class);
-    if (release != null) {
-      try {
-        final String versionName =
-            release.substring(release.indexOf('@') + 1, release.indexOf('+'));
-        final String versionCode = release.substring(release.indexOf('+') + 1);
-        app.setAppVersion(versionName);
-        app.setAppBuild(versionCode);
-      } catch (Throwable e) {
-        options
-            .getLogger()
-            .log(SentryLevel.WARNING, "Failed to parse release from scope cache: %s", release);
-      }
-    }
-
     try {
       final ContextUtils.SplitApksInfo splitApksInfo =
           DeviceInfoUtil.getInstance(context, options).getSplitApksInfo();
@@ -448,25 +445,50 @@ private void setApp(final @NotNull SentryBaseEvent event) {
     }
 
     event.getContexts().setApp(app);
+    setAppVersionAndBuild(event);
+  }
+
+  private void setAppVersionAndBuild(final @NotNull SentryBaseEvent event) {
+    final String release = event.getRelease();
+    if (release != null) {
+      try {
+        @Nullable App app = event.getContexts().getApp();
+        if (app == null) {
+          app = new App();
+        }
+        final String versionName =
+            release.substring(release.indexOf('@') + 1, release.indexOf('+'));
+        final String versionCode = release.substring(release.indexOf('+') + 1);
+        app.setAppVersion(versionName);
+        app.setAppBuild(versionCode);
+        event.getContexts().setApp(app);
+      } catch (Throwable e) {
+        options
+            .getLogger()
+            .log(SentryLevel.WARNING, "Failed to parse release from scope cache: %s", release);
+      }
+    }
   }
 
-  private void setRelease(final @NotNull SentryBaseEvent event) {
+  private void setRelease(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     if (event.getRelease() == null) {
-      final String release =
-          PersistingOptionsObserver.read(options, RELEASE_FILENAME, String.class);
-      event.setRelease(release);
+      event.setRelease(
+          getLaunchOption(RELEASE_FILENAME, String.class, options.getRelease(), optionsSource));
     }
   }
 
-  private void setEnvironment(final @NotNull SentryBaseEvent event) {
+  private void setEnvironment(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     if (event.getEnvironment() == null) {
-      final String environment =
-          PersistingOptionsObserver.read(options, ENVIRONMENT_FILENAME, String.class);
-      event.setEnvironment(environment != null ? environment : options.getEnvironment());
+      event.setEnvironment(
+          getLaunchOption(
+              ENVIRONMENT_FILENAME, String.class, options.getEnvironment(), optionsSource));
     }
   }
 
-  private void setDebugMeta(final @NotNull SentryBaseEvent event) {
+  private void setDebugMeta(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     DebugMeta debugMeta = event.getDebugMeta();
 
     if (debugMeta == null) {
@@ -478,7 +500,8 @@ private void setDebugMeta(final @NotNull SentryBaseEvent event) {
     List<DebugImage> images = debugMeta.getImages();
     if (images != null) {
       final String proguardUuid =
-          PersistingOptionsObserver.read(options, PROGUARD_UUID_FILENAME, String.class);
+          getBuildOption(
+              PROGUARD_UUID_FILENAME, String.class, options.getProguardUuid(), optionsSource);
 
       if (proguardUuid != null) {
         final DebugImage debugImage = new DebugImage();
@@ -490,15 +513,14 @@ private void setDebugMeta(final @NotNull SentryBaseEvent event) {
     }
   }
 
-  private void setDist(final @NotNull SentryBaseEvent event) {
+  private void setDist(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     if (event.getDist() == null) {
-      final String dist = PersistingOptionsObserver.read(options, DIST_FILENAME, String.class);
-      event.setDist(dist);
+      event.setDist(getLaunchOption(DIST_FILENAME, String.class, options.getDist(), optionsSource));
     }
-    // if there's no user-set dist, fall back to versionCode from the persisted release string
+    // if there's no user-set dist, fall back to versionCode from the release string
     if (event.getDist() == null) {
-      final String release =
-          PersistingOptionsObserver.read(options, RELEASE_FILENAME, String.class);
+      final String release = event.getRelease();
       if (release != null) {
         try {
           final String versionCode = release.substring(release.indexOf('+') + 1);
@@ -512,20 +534,101 @@ private void setDist(final @NotNull SentryBaseEvent event) {
     }
   }
 
-  private void setSdk(final @NotNull SentryBaseEvent event) {
+  /**
+   * Resolves an option that may change between launches of the same build, such as environment or
+   * tags. A matching persisted value is preferred; the current value is used only when the source
+   * identifies the current app generation or permits a fallback for a missing persisted value.
+   */
+  private <T> @Nullable T getLaunchOption(
+      final @NotNull String fileName,
+      final @NotNull Class<T> clazz,
+      final @Nullable T currentValue,
+      final @NotNull OptionsSource optionsSource) {
+    if (optionsSource == OptionsSource.CURRENT) {
+      return currentValue;
+    } else if (optionsSource == OptionsSource.NONE) {
+      return null;
+    }
+
+    final T persistedValue = PersistingOptionsObserver.read(options, fileName, clazz);
+    return persistedValue != null || optionsSource == OptionsSource.PERSISTED
+        ? persistedValue
+        : currentValue;
+  }
+
+  /**
+   * Resolves metadata that cannot change between launches of the same build, such as the ProGuard
+   * UUID or SDK version. Current metadata is used for exits from the current app generation, while
+   * persisted metadata is reserved for historical exits.
+   */
+  private <T> @Nullable T getBuildOption(
+      final @NotNull String fileName,
+      final @NotNull Class<T> clazz,
+      final @Nullable T currentValue,
+      final @NotNull OptionsSource optionsSource) {
+    if (optionsSource == OptionsSource.CURRENT
+        || optionsSource == OptionsSource.PERSISTED_WITH_CURRENT_FALLBACK) {
+      return currentValue;
+    } else if (optionsSource == OptionsSource.NONE) {
+      return null;
+    }
+    return PersistingOptionsObserver.read(options, fileName, clazz);
+  }
+
+  /**
+   * Chooses the options snapshot that can safely describe an exit by comparing its timestamp with
+   * the current app update time and the persisted cache generation. A markerless legacy cache is
+   * accepted for compatibility; {@link OptionsSource#NONE} is returned when neither current nor
+   * persisted options can be matched to the exit.
+   */
+  private @NotNull OptionsSource getOptionsSource(final @NotNull Backfillable hint) {
+    final @Nullable Long timestamp;
+    if (hint instanceof AbnormalExit) {
+      timestamp = ((AbnormalExit) hint).timestamp();
+    } else if (hint instanceof NativeCrashExit) {
+      timestamp = ((NativeCrashExit) hint).timestamp();
+    } else {
+      timestamp = null;
+    }
+    final Long cachedLastUpdateTime = PersistingOptionsCacheGenerationObserver.read(options);
+    final PackageInfo packageInfo = ContextUtils.getPackageInfo(context, buildInfoProvider);
+    final long currentLastUpdateTime = packageInfo == null ? 0 : packageInfo.lastUpdateTime;
+
+    if (timestamp != null && currentLastUpdateTime > 0 && currentLastUpdateTime <= timestamp) {
+      return cachedLastUpdateTime != null && cachedLastUpdateTime == currentLastUpdateTime
+          ? OptionsSource.PERSISTED_WITH_CURRENT_FALLBACK
+          : OptionsSource.CURRENT;
+    }
+    if (cachedLastUpdateTime == null) {
+      return OptionsSource.PERSISTED;
+    }
+    // A cache generation created after the exit cannot describe that exit.
+    if (timestamp != null && cachedLastUpdateTime > 0 && cachedLastUpdateTime <= timestamp) {
+      return OptionsSource.PERSISTED;
+    }
+    return OptionsSource.NONE;
+  }
+
+  private void setSdk(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     if (event.getSdk() == null) {
       final SdkVersion sdkVersion =
-          PersistingOptionsObserver.read(options, SDK_VERSION_FILENAME, SdkVersion.class);
+          getBuildOption(
+              SDK_VERSION_FILENAME, SdkVersion.class, options.getSdkVersion(), optionsSource);
       event.setSdk(sdkVersion);
     }
   }
 
   @SuppressWarnings("unchecked")
-  private void setOptionsTags(final @NotNull SentryBaseEvent event) {
+  private void setOptionsTags(
+      final @NotNull SentryBaseEvent event, final @NotNull OptionsSource optionsSource) {
     final Map<String, String> tags =
         (Map<String, String>)
-            PersistingOptionsObserver.read(
-                options, PersistingOptionsObserver.TAGS_FILENAME, Map.class);
+            getLaunchOption(
+                PersistingOptionsObserver.TAGS_FILENAME,
+                Map.class,
+                options.getTags(),
+                optionsSource);
     if (tags == null) {
       return;
     }
@@ -542,6 +645,13 @@ private void setOptionsTags(final @NotNull SentryBaseEvent event) {
 
   // endregion
 
+  private enum OptionsSource {
+    CURRENT,
+    PERSISTED,
+    PERSISTED_WITH_CURRENT_FALLBACK,
+    NONE
+  }
+
   @Override
   public @Nullable Long getOrder() {
     return 12000L;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PersistingOptionsCacheGenerationObserver.java b/sentry-android-core/src/main/java/io/sentry/android/core/PersistingOptionsCacheGenerationObserver.java
new file mode 100644
index 00000000000..9b4433e255e
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PersistingOptionsCacheGenerationObserver.java
@@ -0,0 +1,88 @@
+package io.sentry.android.core;
+
+import static io.sentry.cache.PersistingOptionsObserver.OPTIONS_CACHE;
+
+import io.sentry.IOptionsObserver;
+import io.sentry.SentryLevel;
+import io.sentry.SentryOptions;
+import io.sentry.cache.CacheUtils;
+import io.sentry.cache.PersistingOptionsObserver;
+import io.sentry.protocol.SdkVersion;
+import java.util.Map;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Persists the app generation that produced the options cache.
+ *
+ * <p>{@link ApplicationExitInfoEventProcessor} compares the cached {@link
+ * android.content.pm.PackageInfo#lastUpdateTime} with an exit timestamp before reusing
+ * launch-specific options. This prevents options written by a later app update from being attached
+ * to an older ANR or native crash.
+ *
+ * <p>For example:
+ *
+ * <ol>
+ *   <li>The installed build launches for account A and persists account A's tags and replay
+ *       sampling options.
+ *   <li>A later launch of the same build exits before SDK initialization, so it cannot persist a
+ *       new options snapshot.
+ *   <li>The next launch initializes the SDK for account B and reports the previous exit.
+ *   <li>The matching generation marker lets the processor use account A's persisted options instead
+ *       of account B's current options.
+ * </ol>
+ *
+ * <p>This observer must be registered after {@link PersistingOptionsObserver}. Options observers
+ * are notified one at a time, so the first callback to this observer writes the generation marker
+ * only after the preceding observer has persisted the complete options snapshot.
+ */
+final class PersistingOptionsCacheGenerationObserver implements IOptionsObserver {
+  static final String APP_LAST_UPDATE_TIME_FILENAME = "app-last-update-time.json";
+
+  private final @NotNull SentryOptions options;
+  private final long lastUpdateTime;
+
+  PersistingOptionsCacheGenerationObserver(
+      final @NotNull SentryOptions options, final long lastUpdateTime) {
+    this.options = options;
+    this.lastUpdateTime = lastUpdateTime;
+  }
+
+  @Override
+  public void setRelease(final @Nullable String release) {
+    CacheUtils.store(
+        options, Long.toString(lastUpdateTime), OPTIONS_CACHE, APP_LAST_UPDATE_TIME_FILENAME);
+  }
+
+  static @Nullable Long read(final @NotNull SentryOptions options) {
+    final String value =
+        CacheUtils.read(options, OPTIONS_CACHE, APP_LAST_UPDATE_TIME_FILENAME, String.class, null);
+    if (value == null) {
+      return null;
+    }
+    try {
+      return Long.valueOf(value);
+    } catch (NumberFormatException e) {
+      options.getLogger().log(SentryLevel.ERROR, e, "Failed to read options cache generation.");
+      return null;
+    }
+  }
+
+  @Override
+  public void setProguardUuid(final @Nullable String proguardUuid) {}
+
+  @Override
+  public void setSdkVersion(final @Nullable SdkVersion sdkVersion) {}
+
+  @Override
+  public void setEnvironment(final @Nullable String environment) {}
+
+  @Override
+  public void setDist(final @Nullable String dist) {}
+
+  @Override
+  public void setTags(final @NotNull Map<String, @NotNull String> tags) {}
+
+  @Override
+  public void setReplayErrorSampleRate(final @Nullable Double replayErrorSampleRate) {}
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
index f8724d286f8..cbe42faa103 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
@@ -843,6 +843,21 @@ class AndroidOptionsInitializerTest {
     assertTrue { fixture.sentryOptions.optionsObservers.any { it is PersistingOptionsObserver } }
   }
 
+  @Test
+  fun `options cache generation observer is set when app update time is valid`() {
+    val buildInfo = mock<BuildInfoProvider>()
+    whenever(buildInfo.sdkInfoVersion).thenReturn(Build.VERSION_CODES.LOLLIPOP)
+    ContextUtils.getPackageInfo(fixture.context, buildInfo)!!.lastUpdateTime = 1_000L
+
+    fixture.initSut(useRealContext = true)
+
+    assertTrue {
+      fixture.sentryOptions.optionsObservers.any {
+        it is PersistingOptionsCacheGenerationObserver
+      }
+    }
+  }
+
   @Test
   fun `when cacheDir is not set, persisting observers are not set to options`() {
     fixture.initSut(configureOptions = { cacheDirPath = null })
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
index e7583429910..d5b916d3b44 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
@@ -27,6 +27,7 @@ import io.sentry.cache.PersistingOptionsObserver.PROGUARD_UUID_FILENAME
 import io.sentry.cache.PersistingOptionsObserver.RELEASE_FILENAME
 import io.sentry.cache.PersistingOptionsObserver.REPLAY_ERROR_SAMPLE_RATE_FILENAME
 import io.sentry.cache.PersistingOptionsObserver.SDK_VERSION_FILENAME
+import io.sentry.cache.PersistingOptionsObserver.TAGS_FILENAME as OPTIONS_TAGS_FILENAME
 import io.sentry.cache.PersistingScopeObserver
 import io.sentry.cache.PersistingScopeObserver.BREADCRUMBS_FILENAME
 import io.sentry.cache.PersistingScopeObserver.CONTEXTS_FILENAME
@@ -152,7 +153,7 @@ class ApplicationExitInfoEventProcessorTest {
         persistOptions(SDK_VERSION_FILENAME, SdkVersion("sentry.java.android", "6.15.0"))
         persistOptions(DIST_FILENAME, "232")
         persistOptions(ENVIRONMENT_FILENAME, "debug")
-        persistOptions(TAGS_FILENAME, mapOf("option" to "tag"))
+        persistOptions(OPTIONS_TAGS_FILENAME, mapOf("option" to "tag"))
         replayErrorSampleRate?.let {
           persistOptions(REPLAY_ERROR_SAMPLE_RATE_FILENAME, it.toString())
         }
@@ -198,6 +199,7 @@ class ApplicationExitInfoEventProcessorTest {
   @BeforeTest
   fun `set up`() {
     DeviceInfoUtil.resetInstance()
+    ContextUtils.resetInstance()
     fixture.context = ApplicationProvider.getApplicationContext()
   }
 
@@ -390,14 +392,199 @@ class ApplicationExitInfoEventProcessorTest {
   }
 
   @Test
-  fun `if environment is not persisted, uses environment from options`() {
-    val hint = HintUtils.createWithTypeCheckHint(BackfillableHint())
+  fun `if environment is not persisted and app was not updated, uses environment from options`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 2_000))
+    setLastUpdateTime(1_000)
 
     val processed = processEvent(hint)
 
     assertEquals("release", processed.environment)
   }
 
+  @Test
+  fun `if release is not persisted and app was not updated, uses release from options`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 2_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@1.2.0+232"
+    setLastUpdateTime(1_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertEquals("io.sentry.samples@1.2.0+232", processed.release)
+  }
+
+  @Test
+  fun `if release is not persisted and app was updated, leaves release empty`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 1_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@1.2.0+232"
+    setLastUpdateTime(2_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertNull(processed.release)
+  }
+
+  @Test
+  fun `if exit timestamp is unknown, leaves release empty`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint())
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@1.2.0+232"
+    setLastUpdateTime(1_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertNull(processed.release)
+  }
+
+  @Test
+  fun `if last update time is invalid, leaves release empty`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 1_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@1.2.0+232"
+    setLastUpdateTime(-1)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertNull(processed.release)
+  }
+
+  @Test
+  fun `if dist is not persisted and app was not updated, uses version code from options release`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 2_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@1.2.0+232"
+    setLastUpdateTime(1_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertEquals("232", processed.dist)
+  }
+
+  @Test
+  fun `if app version is not persisted and app was not updated, uses options release`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 2_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@1.2.0+232"
+    setLastUpdateTime(1_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertEquals("1.2.0", processed.contexts.app!!.appVersion)
+    assertEquals("232", processed.contexts.app!!.appBuild)
+  }
+
+  @Test
+  fun `historical event uses current options when app was not updated`() {
+    val hint =
+      HintUtils.createWithTypeCheckHint(AbnormalExitHint(shouldEnrich = false, timestamp = 2_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@1.2.0+232"
+    fixture.options.environment = "production"
+    fixture.options.dist = "custom-dist"
+    setLastUpdateTime(1_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertEquals("io.sentry.samples@1.2.0+232", processed.release)
+    assertEquals("production", processed.environment)
+    assertEquals("custom-dist", processed.dist)
+    val app = processed.contexts.app!!
+    assertEquals("1.2.0", app.appVersion)
+    assertEquals("232", app.appBuild)
+    assertNull(app.appName)
+    assertNull(app.appIdentifier)
+  }
+
+  @Test
+  fun `if options cache is from an older app update, uses current options`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 3_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@2.0.0+300"
+    fixture.options.environment = "current-user"
+    fixture.options.dist = "current-dist"
+    fixture.options.proguardUuid = "current-uuid"
+    fixture.options.sdkVersion = SdkVersion("current-sdk", "2.0.0")
+    fixture.options.setTag("account", "current-tag")
+    fixture.persistOptions(RELEASE_FILENAME, "io.sentry.samples@1.0.0+100")
+    fixture.persistOptions(ENVIRONMENT_FILENAME, "previous-user")
+    fixture.persistOptions(DIST_FILENAME, "previous-dist")
+    fixture.persistOptions(PROGUARD_UUID_FILENAME, "previous-uuid")
+    fixture.persistOptions(SDK_VERSION_FILENAME, SdkVersion("previous-sdk", "1.0.0"))
+    fixture.persistOptions(OPTIONS_TAGS_FILENAME, mapOf("account" to "previous-tag"))
+    PersistingOptionsCacheGenerationObserver(fixture.options, 1_000L).setRelease(null)
+    setLastUpdateTime(2_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertEquals("io.sentry.samples@2.0.0+300", processed.release)
+    assertEquals("current-user", processed.environment)
+    assertEquals("current-dist", processed.dist)
+    assertEquals("current-uuid", processed.debugMeta!!.images!![0].uuid)
+    assertEquals("current-sdk", processed.sdk!!.name)
+    assertEquals("current-tag", processed.tags!!["account"])
+  }
+
+  @Test
+  fun `if options cache is from current app update, uses persisted options`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 2_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@1.0.0+100"
+    fixture.options.environment = "current-user"
+    fixture.options.dist = "current-dist"
+    fixture.options.setTag("account", "current-tag")
+    fixture.persistOptions(RELEASE_FILENAME, "io.sentry.samples@1.0.0+100")
+    fixture.persistOptions(ENVIRONMENT_FILENAME, "crashed-user")
+    fixture.persistOptions(DIST_FILENAME, "crashed-dist")
+    fixture.persistOptions(OPTIONS_TAGS_FILENAME, mapOf("account" to "crashed-tag"))
+    PersistingOptionsCacheGenerationObserver(fixture.options, 1_000L).setRelease(null)
+    setLastUpdateTime(1_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertEquals("io.sentry.samples@1.0.0+100", processed.release)
+    assertEquals("crashed-user", processed.environment)
+    assertEquals("crashed-dist", processed.dist)
+    assertEquals("crashed-tag", processed.tags!!["account"])
+  }
+
+  @Test
+  fun `if options cache was written after the exit, ignores persisted options`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 2_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.persistOptions(RELEASE_FILENAME, "io.sentry.samples@2.0.0+200")
+    fixture.persistOptions(ENVIRONMENT_FILENAME, "newer-user")
+    fixture.persistOptions(DIST_FILENAME, "newer-dist")
+    fixture.persistOptions(PROGUARD_UUID_FILENAME, "newer-uuid")
+    fixture.persistOptions(SDK_VERSION_FILENAME, SdkVersion("newer-sdk", "2.0.0"))
+    fixture.persistOptions(OPTIONS_TAGS_FILENAME, mapOf("account" to "newer-tag"))
+    PersistingOptionsCacheGenerationObserver(fixture.options, 2_500L).setRelease(null)
+    setLastUpdateTime(3_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertNull(processed.release)
+    assertNull(processed.environment)
+    assertNull(processed.dist)
+    assertTrue(processed.debugMeta!!.images!!.isEmpty())
+    assertNull(processed.sdk)
+    assertNull(processed.tags?.get("account"))
+  }
+
+  @Test
+  fun `historical event leaves release empty when app was updated`() {
+    val hint =
+      HintUtils.createWithTypeCheckHint(AbnormalExitHint(shouldEnrich = false, timestamp = 1_000))
+    val processor = fixture.getSut(tmpDir)
+    fixture.options.release = "io.sentry.samples@1.2.0+232"
+    setLastUpdateTime(2_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertNull(processed.release)
+    assertNull(processed.contexts.app)
+  }
+
   @Test
   fun `if dist is not persisted, backfills it from release`() {
     val hint = HintUtils.createWithTypeCheckHint(BackfillableHint())
@@ -890,6 +1077,39 @@ class ApplicationExitInfoEventProcessorTest {
     assertNull(processed.contexts[Contexts.REPLAY_ID])
   }
 
+  @Test
+  fun `if options cache is current, uses persisted replay error sample rate`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 2_000))
+    val processor = fixture.getSut(tmpDir, populateScopeCache = true)
+    fixture.options.sessionReplay.onErrorSampleRate = 1.0
+    fixture.persistOptions(REPLAY_ERROR_SAMPLE_RATE_FILENAME, "0.0")
+    PersistingOptionsCacheGenerationObserver(fixture.options, 1_000L).setRelease(null)
+    setLastUpdateTime(1_000)
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertNull(processed.contexts[Contexts.REPLAY_ID])
+  }
+
+  @Test
+  fun `if options cache is stale, uses current replay error sample rate`() {
+    val hint = HintUtils.createWithTypeCheckHint(AbnormalExitHint(timestamp = 3_000))
+    val processor = fixture.getSut(tmpDir, populateScopeCache = true)
+    fixture.options.sessionReplay.onErrorSampleRate = 1.0
+    fixture.persistOptions(REPLAY_ERROR_SAMPLE_RATE_FILENAME, "0.0")
+    PersistingOptionsCacheGenerationObserver(fixture.options, 1_000L).setRelease(null)
+    setLastUpdateTime(2_000)
+    val replayId = SentryId()
+    File(fixture.options.cacheDirPath, "replay_$replayId").also {
+      it.mkdirs()
+      it.setLastModified(1_000)
+    }
+
+    val processed = processor.process(SentryEvent(), hint)!!
+
+    assertEquals(replayId.toString(), processed.contexts[Contexts.REPLAY_ID].toString())
+  }
+
   @Test
   fun `set replayId of the last modified folder`() {
     val hint = HintUtils.createWithTypeCheckHint(BackfillableHint())
@@ -938,15 +1158,21 @@ class ApplicationExitInfoEventProcessorTest {
     return processor.process(original, hint)!!
   }
 
+  private fun setLastUpdateTime(lastUpdateTime: Long) {
+    ContextUtils.getPackageInfo(fixture.context, fixture.buildInfo)!!.lastUpdateTime =
+      lastUpdateTime
+  }
+
   internal class AbnormalExitHint(
     val mechanism: String? = null,
     private val shouldEnrich: Boolean = true,
+    private val timestamp: Long? = null,
   ) : AbnormalExit, Backfillable {
     override fun mechanism(): String? = mechanism
 
     override fun ignoreCurrentThread(): Boolean = false
 
-    override fun timestamp(): Long? = null
+    override fun timestamp(): Long? = timestamp
 
     override fun shouldEnrich(): Boolean = shouldEnrich
   }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 0e5aad4826b..d1aecf5ccfd 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -4821,6 +4821,11 @@ public final class io/sentry/backpressure/NoOpBackpressureMonitor : io/sentry/ba
 	public fun start ()V
 }
 
+public final class io/sentry/cache/CacheUtils {
+	public static fun read (Lio/sentry/SentryOptions;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Class;Lio/sentry/JsonDeserializer;)Ljava/lang/Object;
+	public static fun store (Lio/sentry/SentryOptions;Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)V
+}
+
 public class io/sentry/cache/EnvelopeCache : io/sentry/cache/IEnvelopeCache {
 	public static final field CRASH_MARKER_FILE Ljava/lang/String;
 	public static final field NATIVE_CRASH_MARKER_FILE Ljava/lang/String;
diff --git a/sentry/src/main/java/io/sentry/cache/CacheUtils.java b/sentry/src/main/java/io/sentry/cache/CacheUtils.java
index 5f578191bd5..142b7c3fdab 100644
--- a/sentry/src/main/java/io/sentry/cache/CacheUtils.java
+++ b/sentry/src/main/java/io/sentry/cache/CacheUtils.java
@@ -18,15 +18,19 @@
 import java.io.Reader;
 import java.io.Writer;
 import java.nio.charset.Charset;
+import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-final class CacheUtils {
+@ApiStatus.Internal
+public final class CacheUtils {
 
   @SuppressWarnings("CharsetObjectCanBeUsed")
   private static final Charset UTF_8 = Charset.forName("UTF-8");
 
-  static <T> void store(
+  private CacheUtils() {}
+
+  public static <T> void store(
       final @NotNull SentryOptions options,
       final @NotNull T entity,
       final @NotNull String dirName,
@@ -63,7 +67,7 @@ static void delete(
     }
   }
 
-  static <T, R> @Nullable T read(
+  public static <T, R> @Nullable T read(
       final @NotNull SentryOptions options,
       final @NotNull String dirName,
       final @NotNull String fileName,

From 5ed4fea07737c2a1cf1dc8c04204d35e4bda7768 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 17 Jul 2026 12:07:09 +0000
Subject: [PATCH 304/391] chore(deps): bump the github-actions group with 3
 updates (#5780)

Bumps the github-actions group with 3 updates: [actions/setup-java](https://github.com/actions/setup-java), [github/codeql-action/init](https://github.com/github/codeql-action) and [github/codeql-action/analyze](https://github.com/github/codeql-action).


Updates `actions/setup-java` from 5.5.0 to 5.6.0
- [Release notes](https://github.com/actions/setup-java/releases)
- [Commits](https://github.com/actions/setup-java/compare/0f481fcb613427c0f801b606911222b5b6f3083a...03ad4de0992f5dab5e18fcb136590ce7c4a0ac95)

Updates `github/codeql-action/init` from 4.37.0 to 4.37.1
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/99df26d4f13ea111d4ec1a7dddef6063f76b97e9...7188fc363630916deb702c7fdcf4e481b751f97a)

Updates `github/codeql-action/analyze` from 4.37.0 to 4.37.1
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/99df26d4f13ea111d4ec1a7dddef6063f76b97e9...7188fc363630916deb702c7fdcf4e481b751f97a)

---
updated-dependencies:
- dependency-name: actions/setup-java
  dependency-version: 5.6.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: github/codeql-action/init
  dependency-version: 4.37.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.37.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/codeql-analysis.yml               | 6 +++---
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 15 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 1d2a3bbb567..5251236fd54 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -33,7 +33,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index a11da2987dd..4ab77129172 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -25,7 +25,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 0c4fda8cfd3..ef7e91d8cfb 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -25,7 +25,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # pin@v2
+        uses: github/codeql-action/init@7188fc363630916deb702c7fdcf4e481b751f97a # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@99df26d4f13ea111d4ec1a7dddef6063f76b97e9 # pin@v2
+        uses: github/codeql-action/analyze@7188fc363630916deb702c7fdcf4e481b751f97a # pin@v2
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index 0604179edda..a5aee08bceb 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -14,7 +14,7 @@ jobs:
         uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
 
       - name: Set up Java
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index e860ef74f14..21b7373a361 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -13,7 +13,7 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index f6de0912fd4..e987a0eedbf 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -14,7 +14,7 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index a2728bc9694..ab6c3de9bcf 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -32,7 +32,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -82,7 +82,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index e8e0df16285..f72a221e00f 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -23,7 +23,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Setup Java Version
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: "temurin"
           java-version: "17"
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 6eeaf4e919d..fff6ef6fa38 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -30,7 +30,7 @@ jobs:
         uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Set up Java 17
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index a1f02d8512d..bd5995e57dd 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -27,7 +27,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index e1a334e48a2..4d213470aed 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -20,7 +20,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 2cee0e04441..2d0c0909526 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index e689bc4c0b7..ba44ea01b65 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index cf30cf0500f..e2fb0aeccee 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index b26632f7f65..1f0f53c6eed 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -112,7 +112,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@0f481fcb613427c0f801b606911222b5b6f3083a # v5
+        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
         with:
           distribution: 'temurin'
           java-version: '17'

From 0ee65e9bc88b40b1a6739d4cb1d8a3a8d6754dfe Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 17 Jul 2026 16:10:57 +0200
Subject: [PATCH 305/391] feat(samples): Make Native Crash button fault inside
 app native code (#5773)

The Native Crash button called raise(SIGSEGV), which faults inside libc and, for a JNI-originated crash, does not exercise symbolication of the app's own native code. Point it at a null-deref inside a named function (trigger_null_deref) instead, so the crashing frame resolves to a real symbol + source line and native symbolication can be verified from the sample.

Ref JAVA-645


Claude-Session: https://claude.ai/code/session_01EmE8hdaj9H9K61opK2PZ6U

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .../src/main/cpp/native-sample.cpp                   | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/sentry-samples/sentry-samples-android/src/main/cpp/native-sample.cpp b/sentry-samples/sentry-samples-android/src/main/cpp/native-sample.cpp
index abac2bf58fe..6b9e6e89d87 100644
--- a/sentry-samples/sentry-samples-android/src/main/cpp/native-sample.cpp
+++ b/sentry-samples/sentry-samples-android/src/main/cpp/native-sample.cpp
@@ -1,15 +1,23 @@
 #include <jni.h>
 #include <android/log.h>
 #include <sentry.h>
-#include <signal.h>
 
 #define TAG "sentry-sample"
 
 extern "C" {
 
+// Faults inside this named function so the crashing frame resolves to a real
+// symbol + source line. A bare raise(SIGSEGV) would instead fault in libc and,
+// for a JNI-originated crash, not exercise app-native symbolication.
+[[gnu::noinline]]
+static void trigger_null_deref() {
+    volatile int *ptr = nullptr;
+    *ptr = 42;
+}
+
 JNIEXPORT void JNICALL Java_io_sentry_samples_android_NativeSample_crash(JNIEnv *env, jclass cls) {
     __android_log_print(ANDROID_LOG_WARN, TAG, "About to crash.");
-    raise(SIGSEGV);
+    trigger_null_deref();
 }
 
 JNIEXPORT void JNICALL Java_io_sentry_samples_android_NativeSample_message(JNIEnv *env, jclass cls) {

From 47b5ffaf47c5194ed2ad10246e896cb349aa5842 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 20 Jul 2026 11:50:40 +0200
Subject: [PATCH 306/391] chore(deps): bump actions/setup-python in the
 github-actions group (#5788)

Bumps the github-actions group with 1 update: [actions/setup-python](https://github.com/actions/setup-python).


Updates `actions/setup-python` from 6.3.0 to 7.0.0
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/ece7cb06caefa5fff74198d8649806c4678c61a1...5fda3b95a4ea91299a34e894583c3862153e4b97)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-version: 7.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/spring-boot-2-matrix.yml | 2 +-
 .github/workflows/spring-boot-3-matrix.yml | 2 +-
 .github/workflows/spring-boot-4-matrix.yml | 2 +-
 .github/workflows/system-tests-backend.yml | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 2d0c0909526..aa0c66f9562 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -35,7 +35,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Set up Python
-        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
         with:
           python-version: '3.10.5'
 
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index ba44ea01b65..24e86afbc04 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -35,7 +35,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Set up Python
-        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
         with:
           python-version: '3.10.5'
 
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index e2fb0aeccee..6a6dda337f1 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -35,7 +35,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Set up Python
-        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
         with:
           python-version: '3.10.5'
 
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 1f0f53c6eed..feac0a4f3a7 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -102,7 +102,7 @@ jobs:
         with:
           submodules: 'recursive'
 
-      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6
+      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
         with:
           python-version: '3.10.5'
 

From eb1a94667b39a0dc8ae51955daafa26ec3504334 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Mon, 20 Jul 2026 13:12:44 +0200
Subject: [PATCH 307/391] fix(compose): Update isImportantForBounds to return
 true (#5789)

* fix(compose): Update isImportantForBounds to return true

As any inner node could be important for semantics.

* Update CHANGELOG

* Format code

---------

Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                         |  1 +
 .../kotlin/io/sentry/compose/SentryModifier.kt       | 12 +++++-------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 44231ff4eed..f1d98e41ebc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Fixes
 
 - Backfill release, environment, distribution, tags, and app version/build—and use the matching replay-on-error sample rate—for `ApplicationExitInfo` ANR and native crash events captured before SDK initialization, without reusing options cached by a later app update ([#5762](https://github.com/getsentry/sentry-java/pull/5762))
+- `SentryTagModifierNode.isImportantForBounds` now matches the default behavior and returns `true` ([#5789](https://github.com/getsentry/sentry-java/pull/5789))
 
 ## 8.49.0
 
diff --git a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryModifier.kt b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryModifier.kt
index 787c66b3b0b..3c8fb48c35a 100644
--- a/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryModifier.kt
+++ b/sentry-compose/src/androidMain/kotlin/io/sentry/compose/SentryModifier.kt
@@ -55,13 +55,11 @@ public object SentryModifier {
     }
 
     // SemanticsModifierNode.isImportantForBounds() was added as an abstract method in
-    // compose-ui 1.11.  Classes compiled against earlier versions lack this method in
+    // compose-ui 1.11. Classes compiled against earlier versions lack this method in
     // their bytecode, which causes AbstractMethodError when the accessibility tree is
-    // traversed on 1.11+ runtimes.  We can't use the `override` keyword here because
-    // the method doesn't exist in the compile-time dependency (compose-ui 1.6.x), but
-    // the JVM satisfies the abstract-method requirement at runtime via signature
-    // matching.  SentryTagModifierNode only stores a semantic tag and has no visual
-    // effect on layout, so it is not important for bounds.
-    @Suppress("unused") fun isImportantForBounds(): Boolean = false
+    // traversed on 1.11+ runtimes.
+    // Returning true to match the default behavior
+    // https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/node/SemanticsModifierNode.kt;l=69-83;drc=bd7809b4bc9205721c2f1bc681694dd348885849
+    @Suppress("unused") fun isImportantForBounds(): Boolean = true
   }
 }

From 747ff0be2ed03fbc866e99801ee7e0a70de0e70b Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 20 Jul 2026 14:17:10 +0200
Subject: [PATCH 308/391] fix(core): Prevent recursion when a callback triggers
 another capture (#5737)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(core): Prevent recursion when a callback triggers another capture

A user beforeSend/beforeBreadcrumb/beforeSendLog callback that itself
captures — directly, or transitively through a logging integration that
routes back into Sentry (e.g. Timber, or the Gradle plugin's logcat
instrumentation) — recursed until a StackOverflowError, because the callbacks
run synchronously on the caller thread with no re-entrancy protection.

Add a shared, thread-local SentryCallbackReentrancyGuard that is set only
while a callback's execute() runs. Capture entry points (captureEvent,
captureTransaction, captureLog, Scope.addBreadcrumb) drop nested captures
while the guard is active, breaking the loop for every capture type at once.
Dropping (rather than sending) the nested capture is intentional: bypassing
beforeSend would send unscrubbed data.

The nested capture is dropped, not sent. This also makes the per-integration
guard in SentryLogcatAdapter redundant.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* docs(changelog): Add entry for callback re-entrancy guard

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(core): Guard captureFeedback, captureReplayEvent, captureMetric too

These three capture methods had their beforeSend* executors wrapped by the
re-entrancy guard but no entry check, so they were never dropped when a
callback was active. That broke the "callbacks never nest" invariant: a
callback that captured feedback/replay/metric ran that executor, whose exit()
cleared the shared flag mid-callback, re-enabling recursion for any
captureEvent/captureLog that followed in the same callback. They also recursed
directly (e.g. beforeSendFeedback -> captureFeedback).

Add the same isActive() entry guard to all three so every executor-wrapped
capture path also drops while a callback runs.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(core): Harden re-entrancy guard with depth counter, wrap remaining callbacks

Two robustness fixes for the callback re-entrancy guard:

Replace the boolean flag with a depth counter so a nested exit() cannot
disarm the guard while an outer callback is still running. The boolean
relied on the "callbacks never nest" invariant, which every capture entry
point must uphold by convention - a future capture path added without an
entry check would silently re-open the recursion hole. The counter makes
that failure mode structurally impossible, and lets exit() remove() the
thread-local entry instead of parking a stale value on pooled threads.

Wrap beforeErrorSampling and beforeEnvelopeCallback, the two remaining
user callbacks in SentryClient without enter()/exit(). A capture from
within beforeErrorSampling recursed unguarded (captureEvent ->
beforeErrorSampling -> captureEvent -> ...). Both regression tests were
verified to fail with StackOverflowError without the wraps.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* refactor(core): Hand out AutoCloseable token from re-entrancy guard

Replace the manual enter()/finally-exit() pattern at every callback site
with an ISentryLifecycleToken returned from enter(), used via
try-with-resources. This removes nine copies of the finally boilerplate
and the risk of forgetting the exit() call.

The depth counter stays as the guard's state model - the token's close()
just decrements it - so the nesting correctness guarantee is unchanged.
The token is a shared static singleton, so no allocation happens per
callback, matching the AutoClosableReentrantLock idiom already in the
codebase.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Format code

* docs(changelog): Move re-entrancy entry to Unreleased

The rebase folded the previous Unreleased section into the released
8.48.0, stranding the callback re-entrancy entry there. Move it back
under Unreleased.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(core): Guard sendEnvelope against callback re-entrancy

captureEnvelope and captureCheckIn route into sendEnvelope without the
isActive() entry check every other capture path has. A beforeEnvelope
callback that itself captured an envelope or check-in re-entered
sendEnvelope, re-ran the callback, and recursed to a StackOverflowError -
the same failure class the rest of this PR fixes.

Check the guard at the top of sendEnvelope, the single choke point every
send flows through, rather than adding a check to each public entry
point. In normal flow the guard is already inactive there (the before*
callback has exited), so an active guard can only mean a callback
triggered the send, which is dropped. This also closes the hole for any
future sender routed through sendEnvelope.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* test(core): Drop redundant check-in re-entrancy test

captureCheckIn and captureEnvelope both funnel into sendEnvelope and hit
the same isActive() guard, so the check-in test exercised no code path
the envelope test did not already cover.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix(core): Drop callback-recursion captures silently

The re-entrancy guard dropped nested captures but logged a DEBUG line at
seven of the eight drop sites. That log is itself routed back into Sentry
by the same logging integrations this guard protects against (the Gradle
plugin's logcat instrumentation feeds captureLog, whose own drop logs
again), so logging on the drop path re-opens the very recursion the guard
breaks. It only bites with SDK debug logging enabled, since the internal
logger is otherwise a no-op, but dropping silently removes the failure
mode outright.

Drop without logging everywhere and document why in the guard's Javadoc
and at each drop site.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* docs(core): Document that captures inside before* callbacks are dropped

A customer implementing beforeSend/beforeBreadcrumb/beforeSendLog/etc.
has no way to know that capturing from within the callback — directly or
through a logging integration — is silently dropped to prevent recursion.
State the contract on each customer-facing callback interface.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* build(core): Update API dump for re-entrancy guard token

The token refactor changed SentryCallbackReentrancyGuard.enter() to
return an ISentryLifecycleToken and made exit() private, but the API dump
was not regenerated at the time. The guard is @ApiStatus.Internal.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |   2 +
 .../timber/SentryTimberIntegrationTest.kt     |  44 +++++
 sentry/api/sentry.api                         |   5 +
 sentry/src/main/java/io/sentry/Scope.java     |   7 +-
 .../src/main/java/io/sentry/SentryClient.java |  55 +++++-
 .../main/java/io/sentry/SentryOptions.java    |  24 +++
 .../java/io/sentry/SentryReplayOptions.java   |   4 +
 .../util/SentryCallbackReentrancyGuard.java   |  77 +++++++++
 sentry/src/test/java/io/sentry/ScopeTest.kt   |  21 +++
 .../test/java/io/sentry/SentryClientTest.kt   | 158 ++++++++++++++++++
 10 files changed, 388 insertions(+), 9 deletions(-)
 create mode 100644 sentry/src/main/java/io/sentry/util/SentryCallbackReentrancyGuard.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f1d98e41ebc..6d37da44d4b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,8 @@
 
 - Backfill release, environment, distribution, tags, and app version/build—and use the matching replay-on-error sample rate—for `ApplicationExitInfo` ANR and native crash events captured before SDK initialization, without reusing options cached by a later app update ([#5762](https://github.com/getsentry/sentry-java/pull/5762))
 - `SentryTagModifierNode.isImportantForBounds` now matches the default behavior and returns `true` ([#5789](https://github.com/getsentry/sentry-java/pull/5789))
+- Prevent a `StackOverflowError` when a `beforeSend`, `beforeBreadcrumb`, `beforeSendLog`, or `beforeEnvelope` callback triggers another capture (directly or through a logging integration such as Timber) ([#5737](https://github.com/getsentry/sentry-java/pull/5737))
+  - Captures made from within a user callback (event, transaction, breadcrumb, log, envelope, or check-in) are now dropped while that callback runs, instead of recursing. Captures made by event processors are unaffected.
 
 ## 8.49.0
 
diff --git a/sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberIntegrationTest.kt b/sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberIntegrationTest.kt
index 43a45da7bb3..7c21eca8ef0 100644
--- a/sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberIntegrationTest.kt
+++ b/sentry-android-timber/src/test/java/io/sentry/android/timber/SentryTimberIntegrationTest.kt
@@ -1,10 +1,14 @@
 package io.sentry.android.timber
 
 import io.sentry.IScopes
+import io.sentry.ITransportFactory
+import io.sentry.ScopesAdapter
+import io.sentry.Sentry
 import io.sentry.SentryLevel
 import io.sentry.SentryLogLevel
 import io.sentry.SentryOptions
 import io.sentry.protocol.SdkVersion
+import io.sentry.transport.ITransport
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -12,6 +16,7 @@ import kotlin.test.assertTrue
 import org.mockito.kotlin.any
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
 import timber.log.Timber
 
 class SentryTimberIntegrationTest {
@@ -112,4 +117,43 @@ class SentryTimberIntegrationTest {
 
     assertTrue(fixture.options.sdkVersion!!.integrationSet.contains("Timber"))
   }
+
+  @Test
+  fun `a beforeSend callback that logs via Timber does not recurse`() {
+    // End-to-end guard against SDK-CRASHES-JAVA-3T3H style recursion: with a real Sentry instance,
+    // a beforeSend callback that logs through the planted SentryTimberTree must not loop back into
+    // capture forever.
+    val transport = mock<ITransport>()
+    val transportFactory = mock<ITransportFactory>()
+    whenever(transportFactory.create(any(), any())).thenReturn(transport)
+
+    var beforeSendInvocations = 0
+    Sentry.init { options ->
+      options.dsn = "https://key@sentry.io/123"
+      options.setTransportFactory(transportFactory)
+      options.beforeSend = SentryOptions.BeforeSendCallback { event, _ ->
+        beforeSendInvocations++
+        Timber.e("logging from beforeSend")
+        event
+      }
+    }
+    Timber.plant(
+      SentryTimberTree(
+        ScopesAdapter.getInstance(),
+        SentryLevel.ERROR,
+        SentryLevel.INFO,
+        SentryLogLevel.INFO,
+      )
+    )
+
+    try {
+      Timber.e("outer error")
+
+      // Without the core re-entrancy guard this recurses until a StackOverflowError. The nested
+      // Timber.e is dropped before its own beforeSend, so the callback runs exactly once.
+      assertEquals(1, beforeSendInvocations)
+    } finally {
+      Sentry.close()
+    }
+  }
 }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index d1aecf5ccfd..c623e71d08f 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -7924,6 +7924,11 @@ public final class io/sentry/util/ScopesUtil {
 	public static fun printScopesChain (Lio/sentry/IScopes;)V
 }
 
+public final class io/sentry/util/SentryCallbackReentrancyGuard {
+	public static fun enter ()Lio/sentry/ISentryLifecycleToken;
+	public static fun isActive ()Z
+}
+
 public final class io/sentry/util/SentryRandom {
 	public fun <init> ()V
 	public static fun current ()Lio/sentry/util/Random;
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index f5c57f5ac5d..195e5b5b05a 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -16,6 +16,7 @@
 import io.sentry.util.ExceptionUtils;
 import io.sentry.util.Objects;
 import io.sentry.util.Pair;
+import io.sentry.util.SentryCallbackReentrancyGuard;
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -464,7 +465,7 @@ public Queue<Breadcrumb> getBreadcrumbs() {
       final @NotNull SentryOptions.BeforeBreadcrumbCallback callback,
       @NotNull Breadcrumb breadcrumb,
       final @NotNull Hint hint) {
-    try {
+    try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
       breadcrumb = callback.execute(breadcrumb, hint);
     } catch (Throwable e) {
       options
@@ -493,6 +494,10 @@ public void addBreadcrumb(@NotNull Breadcrumb breadcrumb, @Nullable Hint hint) {
     if (breadcrumb == null || breadcrumbs instanceof DisabledQueue) {
       return;
     }
+    // Drop silently to prevent recursion; a log here can re-enter through a logging integration.
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      return;
+    }
     SentryOptions.BeforeBreadcrumbCallback callback = options.getBeforeBreadcrumb();
     if (callback != null) {
       if (hint == null) {
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index a0ff98a9af7..a25aa9c79e1 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -107,6 +107,11 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
       @NotNull SentryEvent event, final @Nullable IScope scope, @Nullable Hint hint) {
     Objects.requireNonNull(event, "SentryEvent is required.");
 
+    // Drop silently to prevent recursion; a log here can re-enter through a logging integration.
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      return SentryId.EMPTY_ID;
+    }
+
     if (hint == null) {
       hint = new Hint();
     }
@@ -236,7 +241,7 @@ private boolean shouldApplyScopeData(final @NotNull CheckIn event, final @NotNul
       final SentryReplayOptions.BeforeErrorSamplingCallback beforeErrorSampling =
           options.getSessionReplay().getBeforeErrorSampling();
       if (beforeErrorSampling != null) {
-        try {
+        try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
           shouldCaptureReplay = beforeErrorSampling.execute(event, hint);
         } catch (Throwable e) {
           options
@@ -312,6 +317,11 @@ private void finalizeTransaction(final @NotNull IScope scope, final @NotNull Hin
       @NotNull SentryReplayEvent event, final @Nullable IScope scope, @Nullable Hint hint) {
     Objects.requireNonNull(event, "SessionReplay is required.");
 
+    // Drop silently to prevent recursion; a log here can re-enter through a logging integration.
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      return SentryId.EMPTY_ID;
+    }
+
     if (hint == null) {
       hint = new Hint();
     }
@@ -937,10 +947,19 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
 
   private @NotNull SentryId sendEnvelope(
       @NotNull final SentryEnvelope envelope, @Nullable final Hint hint) throws IOException {
+    // captureEnvelope and captureCheckIn have no entry-level guard, so a callback that captures
+    // one of those would recurse back into beforeEnvelopeCallback. In normal flow the guard is
+    // already inactive by the time we get here (the before* callback has exited), so an active
+    // guard means a callback triggered this send. Drop silently: a log here can re-enter through a
+    // logging integration.
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      return SentryId.EMPTY_ID;
+    }
+
     final @Nullable SentryOptions.BeforeEnvelopeCallback beforeEnvelopeCallback =
         options.getBeforeEnvelopeCallback();
     if (beforeEnvelopeCallback != null) {
-      try {
+      try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         beforeEnvelopeCallback.execute(envelope, hint);
       } catch (Throwable e) {
         options
@@ -969,6 +988,11 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
       final @Nullable ProfilingTraceData profilingTraceData) {
     Objects.requireNonNull(transaction, "Transaction is required.");
 
+    // Drop silently to prevent recursion; a log here can re-enter through a logging integration.
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      return SentryId.EMPTY_ID;
+    }
+
     if (hint == null) {
       hint = new Hint();
     }
@@ -1187,6 +1211,11 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
   @Override
   public @NotNull SentryId captureFeedback(
       final @NotNull Feedback feedback, @Nullable Hint hint, final @NotNull IScope scope) {
+    // Drop silently to prevent recursion; a log here can re-enter through a logging integration.
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      return SentryId.EMPTY_ID;
+    }
+
     SentryEvent event = new SentryEvent();
     event.getContexts().setFeedback(feedback);
 
@@ -1297,6 +1326,11 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
   @ApiStatus.Experimental
   @Override
   public void captureLog(@Nullable SentryLogEvent logEvent, @Nullable IScope scope) {
+    // Drop silently to prevent recursion; a log here can re-enter through a logging integration.
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      return;
+    }
+
     if (logEvent != null && scope != null) {
       logEvent = processLogEvent(logEvent, scope.getEventProcessors());
       if (logEvent == null) {
@@ -1351,6 +1385,11 @@ public void captureMetric(
       @Nullable SentryMetricsEvent metricsEvent,
       final @Nullable IScope scope,
       @Nullable Hint hint) {
+    // Drop silently to prevent recursion; a log here can re-enter through a logging integration.
+    if (SentryCallbackReentrancyGuard.isActive()) {
+      return;
+    }
+
     if (hint == null) {
       hint = new Hint();
     }
@@ -1612,7 +1651,7 @@ private void sortBreadcrumbsByDate(
       @NotNull SentryEvent event, final @NotNull Hint hint) {
     final SentryOptions.BeforeSendCallback beforeSend = options.getBeforeSend();
     if (beforeSend != null) {
-      try {
+      try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSend.execute(event, hint);
       } catch (Throwable e) {
         options
@@ -1634,7 +1673,7 @@ private void sortBreadcrumbsByDate(
     final SentryOptions.BeforeSendTransactionCallback beforeSendTransaction =
         options.getBeforeSendTransaction();
     if (beforeSendTransaction != null) {
-      try {
+      try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         transaction = beforeSendTransaction.execute(transaction, hint);
       } catch (Throwable e) {
         options
@@ -1655,7 +1694,7 @@ private void sortBreadcrumbsByDate(
       @NotNull SentryEvent event, final @NotNull Hint hint) {
     final SentryOptions.BeforeSendCallback beforeSendFeedback = options.getBeforeSendFeedback();
     if (beforeSendFeedback != null) {
-      try {
+      try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSendFeedback.execute(event, hint);
       } catch (Throwable e) {
         options
@@ -1673,7 +1712,7 @@ private void sortBreadcrumbsByDate(
       @NotNull SentryReplayEvent event, final @NotNull Hint hint) {
     final SentryOptions.BeforeSendReplayCallback beforeSendReplay = options.getBeforeSendReplay();
     if (beforeSendReplay != null) {
-      try {
+      try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSendReplay.execute(event, hint);
       } catch (Throwable e) {
         options
@@ -1694,7 +1733,7 @@ private void sortBreadcrumbsByDate(
     final SentryOptions.Logs.BeforeSendLogCallback beforeSendLog =
         options.getLogs().getBeforeSend();
     if (beforeSendLog != null) {
-      try {
+      try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSendLog.execute(event);
       } catch (Throwable e) {
         options
@@ -1716,7 +1755,7 @@ private void sortBreadcrumbsByDate(
     final SentryOptions.Metrics.BeforeSendMetricCallback beforeSendMetric =
         options.getMetrics().getBeforeSend();
     if (beforeSendMetric != null) {
-      try {
+      try (final @NotNull ISentryLifecycleToken ignored = SentryCallbackReentrancyGuard.enter()) {
         event = beforeSendMetric.execute(event, hint);
       } catch (Throwable e) {
         options
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index cde0c37ba90..f10f2aede05 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -3327,6 +3327,10 @@ public interface BeforeSendCallback {
     /**
      * Mutates or drop an event before being sent
      *
+     * <p>Do not capture from within this callback — directly, or indirectly through a logging
+     * integration that routes logs back into Sentry. Such nested captures are silently dropped to
+     * prevent infinite recursion.
+     *
      * @param event the event
      * @param hint the hints
      * @return the original event or the mutated event or null if event was dropped
@@ -3341,6 +3345,10 @@ public interface BeforeSendTransactionCallback {
     /**
      * Mutates or drop a transaction before being sent
      *
+     * <p>Do not capture from within this callback — directly, or indirectly through a logging
+     * integration that routes logs back into Sentry. Such nested captures are silently dropped to
+     * prevent infinite recursion.
+     *
      * @param transaction the transaction
      * @param hint the hints
      * @return the original transaction or the mutated transaction or null if transaction was
@@ -3358,6 +3366,10 @@ public interface BeforeSendReplayCallback {
      * for a single replay (i.e. segments), you can check {@link SentryReplayEvent#getReplayId()} to
      * identify that the segments belong to the same replay.
      *
+     * <p>Do not capture from within this callback — directly, or indirectly through a logging
+     * integration that routes logs back into Sentry. Such nested captures are silently dropped to
+     * prevent infinite recursion.
+     *
      * @param event the event
      * @param hint the hint, contains {@link ReplayRecording}, can be accessed via {@link
      *     Hint#getReplayRecording()}
@@ -3373,6 +3385,10 @@ public interface BeforeBreadcrumbCallback {
     /**
      * Mutates or drop a callback before being added
      *
+     * <p>Do not capture from within this callback — directly, or indirectly through a logging
+     * integration that routes logs back into Sentry. Such nested captures are silently dropped to
+     * prevent infinite recursion.
+     *
      * @param breadcrumb the breadcrumb
      * @param hint the hints, usually the source of the breadcrumb
      * @return the original breadcrumb or the mutated breadcrumb of null if breadcrumb was dropped
@@ -3961,6 +3977,10 @@ public interface BeforeSendLogCallback {
       /**
        * Mutates or drop a log event before being sent
        *
+       * <p>Do not capture from within this callback — directly, or indirectly through a logging
+       * integration that routes logs back into Sentry. Such nested captures are silently dropped to
+       * prevent infinite recursion.
+       *
        * @param event the event
        * @return the original log event or the mutated event or null if event was dropped
        */
@@ -4035,6 +4055,10 @@ public interface BeforeSendMetricCallback {
       /**
        * A callback which gets called right before a metric is about to be sent.
        *
+       * <p>Do not capture from within this callback — directly, or indirectly through a logging
+       * integration that routes logs back into Sentry. Such nested captures are silently dropped to
+       * prevent infinite recursion.
+       *
        * @param metric the metric
        * @return the original metric, mutated metric or null if metric was dropped
        */
diff --git a/sentry/src/main/java/io/sentry/SentryReplayOptions.java b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
index d1da6510cdb..a068e12f2a8 100644
--- a/sentry/src/main/java/io/sentry/SentryReplayOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryReplayOptions.java
@@ -28,6 +28,10 @@ public interface BeforeErrorSamplingCallback {
     /**
      * Determines whether replay capture should proceed for the given error event.
      *
+     * <p>Do not capture from within this callback — directly, or indirectly through a logging
+     * integration that routes logs back into Sentry. Such nested captures are silently dropped to
+     * prevent infinite recursion.
+     *
      * @param event the error event that triggered the replay capture
      * @param hint the hint associated with the event
      * @return {@code true} if the error sample rate should be checked, {@code false} to skip replay
diff --git a/sentry/src/main/java/io/sentry/util/SentryCallbackReentrancyGuard.java b/sentry/src/main/java/io/sentry/util/SentryCallbackReentrancyGuard.java
new file mode 100644
index 00000000000..461e7daf18f
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/SentryCallbackReentrancyGuard.java
@@ -0,0 +1,77 @@
+package io.sentry.util;
+
+import io.sentry.ISentryLifecycleToken;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Thread-local re-entrancy guard that marks whether a user-supplied {@code before*} callback
+ * ({@code beforeSend}, {@code beforeBreadcrumb}, {@code beforeSendLog}, ...) is currently executing
+ * on the current thread.
+ *
+ * <p>A callback that itself triggers another SDK capture on the same thread — directly, or
+ * transitively through a logging integration that routes back into Sentry (e.g. Timber or the
+ * Gradle plugin's logcat instrumentation) — would otherwise recurse indefinitely and throw {@link
+ * StackOverflowError}. Capture entry points consult {@link #isActive()} and drop the nested capture
+ * while a callback is running.
+ *
+ * <p>The nested capture MUST be dropped silently — callers must not log while the guard is active.
+ * The same logging integration that routes logs back into Sentry also routes the SDK's own
+ * diagnostic logs, so a "dropped to prevent recursion" log line would be turned into another
+ * capture, whose drop would log again, and so on. The guard suppresses the capture but not the log,
+ * so logging on the drop path re-opens exactly the recursion the guard exists to break. (This only
+ * bites when SDK debug logging is enabled, since {@code options.getLogger()} is otherwise a no-op,
+ * but dropping silently removes the failure mode entirely.)
+ *
+ * <p>The guard is set ONLY around each callback's {@code execute(...)} invocation, never around the
+ * whole capture pipeline, so captures made by event processors (which run outside the callback) are
+ * not affected.
+ *
+ * <p>The guard is a depth counter rather than a boolean so that nested {@link #exit()} calls cannot
+ * clear it while an outer callback is still running. Capture entry points drop while a callback is
+ * active, so callbacks should never nest — but a capture path lacking an entry check must not
+ * silently disarm the guard for the rest of the outer callback.
+ *
+ * <p>{@link #enter()} returns an {@link ISentryLifecycleToken} so callers can use
+ * try-with-resources instead of a manual {@code finally exit()}. The token is a shared singleton
+ * (its {@code close()} just decrements the counter), so no allocation happens per callback.
+ */
+@ApiStatus.Internal
+public final class SentryCallbackReentrancyGuard {
+
+  private static final ThreadLocal<Integer> depth = new ThreadLocal<>();
+
+  private static final ISentryLifecycleToken TOKEN = SentryCallbackReentrancyGuard::exit;
+
+  private SentryCallbackReentrancyGuard() {}
+
+  /**
+   * Whether a user callback is currently executing on this thread. When {@code true}, capture entry
+   * points must drop the capture and return without logging — see the class Javadoc for why logging
+   * on the drop path re-opens the recursion.
+   */
+  public static boolean isActive() {
+    final @Nullable Integer current = depth.get();
+    return current != null && current > 0;
+  }
+
+  /**
+   * Marks that a user callback is starting to execute on this thread. Close the returned token (via
+   * try-with-resources) once the callback returns.
+   */
+  public static @NotNull ISentryLifecycleToken enter() {
+    final @Nullable Integer current = depth.get();
+    depth.set(current == null ? 1 : current + 1);
+    return TOKEN;
+  }
+
+  private static void exit() {
+    final @Nullable Integer current = depth.get();
+    if (current == null || current <= 1) {
+      depth.remove();
+    } else {
+      depth.set(current - 1);
+    }
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/ScopeTest.kt b/sentry/src/test/java/io/sentry/ScopeTest.kt
index 86aaf6f8f24..7af4f6ccdca 100644
--- a/sentry/src/test/java/io/sentry/ScopeTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopeTest.kt
@@ -371,6 +371,27 @@ class ScopeTest {
     assertFalse(called)
   }
 
+  @Test
+  fun `when beforeBreadcrumb adds another breadcrumb, the nested breadcrumb is dropped and does not recurse`() {
+    var invocations = 0
+    lateinit var scope: Scope
+    val options =
+      SentryOptions().apply {
+        beforeBreadcrumb = SentryOptions.BeforeBreadcrumbCallback { breadcrumb, _ ->
+          invocations++
+          scope.addBreadcrumb(Breadcrumb())
+          breadcrumb
+        }
+      }
+
+    scope = Scope(options)
+    scope.addBreadcrumb(Breadcrumb())
+
+    // Callback runs only for the outer breadcrumb; the nested one is dropped before its callback.
+    assertEquals(1, invocations)
+    assertEquals(1, scope.breadcrumbs.count())
+  }
+
   @Test
   fun `when adding breadcrumb and maxBreadcrumb is not 0, beforeBreadcrumb is executed`() {
     var called = false
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index 5cfa4b6b619..fa37cb0b70b 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -284,6 +284,108 @@ class SentryClientTest {
     )
   }
 
+  @Test
+  fun `when beforeSend captures another event, the nested capture is dropped and does not recurse`() {
+    var invocations = 0
+    lateinit var sut: SentryClient
+    fixture.sentryOptions.setBeforeSend { e, _ ->
+      invocations++
+      sut.captureEvent(SentryEvent())
+      e
+    }
+    sut = fixture.getSut()
+
+    sut.captureEvent(SentryEvent())
+
+    // Callback runs only for the outer event; the nested capture is dropped before its callback.
+    assertEquals(1, invocations)
+    verify(fixture.transport, times(1)).send(any(), anyOrNull())
+  }
+
+  @Test
+  fun `when beforeSend captures a log, the nested log is dropped`() {
+    val scope = createScope()
+    fixture.sentryOptions.logs.isEnabled = true
+    lateinit var sut: SentryClient
+    fixture.sentryOptions.setBeforeSend { e, _ ->
+      sut.captureLog(
+        SentryLogEvent(SentryId(), SentryNanotimeDate(), "nested", SentryLogLevel.WARN),
+        scope,
+      )
+      e
+    }
+    sut = fixture.getSut()
+
+    sut.captureEvent(SentryEvent())
+
+    // The shared guard spans capture types: a log emitted from beforeSend is dropped too.
+    verify(fixture.loggerBatchProcessor, never()).add(any())
+    verify(fixture.transport, times(1)).send(any(), anyOrNull())
+  }
+
+  @Test
+  fun `when beforeSendLog logs again, the nested log is dropped and does not recurse`() {
+    val scope = createScope()
+    fixture.sentryOptions.logs.isEnabled = true
+    var invocations = 0
+    lateinit var sut: SentryClient
+    fixture.sentryOptions.logs.setBeforeSend { l ->
+      invocations++
+      sut.captureLog(
+        SentryLogEvent(SentryId(), SentryNanotimeDate(), "nested", SentryLogLevel.WARN),
+        scope,
+      )
+      l
+    }
+    sut = fixture.getSut()
+
+    sut.captureLog(
+      SentryLogEvent(SentryId(), SentryNanotimeDate(), "outer", SentryLogLevel.WARN),
+      scope,
+    )
+
+    assertEquals(1, invocations)
+    verify(fixture.loggerBatchProcessor, times(1)).add(any())
+  }
+
+  @Test
+  fun `when beforeSend captures feedback before an event, the guard is not cleared prematurely`() {
+    val scope = createScope()
+    var invocations = 0
+    lateinit var sut: SentryClient
+    fixture.sentryOptions.setBeforeSend { e, _ ->
+      invocations++
+      // Capturing feedback must not clear the re-entrancy guard for captures that follow it in the
+      // same callback, otherwise the captureEvent below would recurse.
+      sut.captureFeedback(Feedback("feedback"), null, scope)
+      sut.captureEvent(SentryEvent())
+      e
+    }
+    sut = fixture.getSut()
+
+    sut.captureEvent(SentryEvent())
+
+    assertEquals(1, invocations)
+    verify(fixture.transport, times(1)).send(any(), anyOrNull())
+  }
+
+  @Test
+  fun `when beforeSendFeedback captures feedback again, the nested capture is dropped and does not recurse`() {
+    val scope = createScope()
+    var invocations = 0
+    lateinit var sut: SentryClient
+    fixture.sentryOptions.setBeforeSendFeedback { e, _ ->
+      invocations++
+      sut.captureFeedback(Feedback("nested"), null, scope)
+      e
+    }
+    sut = fixture.getSut()
+
+    sut.captureFeedback(Feedback("outer"), null, scope)
+
+    assertEquals(1, invocations)
+  }
+
   @Test
   fun `when beforeSendLog is set, callback is invoked`() {
     val scope = createScope()
@@ -3188,6 +3290,44 @@ class SentryClientTest {
     assertTrue(beforeEnvelopeCalled)
   }
 
+  @Test
+  fun `when beforeEnvelopeCallback captures another event, the nested capture is dropped and does not recurse`() {
+    var invocations = 0
+    lateinit var sut: SentryClient
+    val options = { options: SentryOptions ->
+      options.beforeEnvelopeCallback = SentryOptions.BeforeEnvelopeCallback { _, _ ->
+        invocations++
+        sut.captureEvent(SentryEvent())
+      }
+    }
+    sut = fixture.getSut(options)
+
+    sut.captureEvent(SentryEvent(), Hint())
+
+    assertEquals(1, invocations)
+    verify(fixture.transport, times(1)).send(any(), anyOrNull())
+  }
+
+  @Test
+  fun `when beforeEnvelopeCallback captures an envelope, the nested envelope is dropped and does not recurse`() {
+    var invocations = 0
+    lateinit var sut: SentryClient
+    val options = { options: SentryOptions ->
+      options.beforeEnvelopeCallback = SentryOptions.BeforeEnvelopeCallback { _, _ ->
+        invocations++
+        sut.captureEnvelope(SentryEnvelope(SentryId(UUID.randomUUID()), null, setOf()))
+      }
+    }
+    sut = fixture.getSut(options)
+
+    sut.captureEvent(SentryEvent(), Hint())
+
+    // Callback runs only for the outer envelope; the nested captureEnvelope is dropped in
+    // sendEnvelope before its callback would run.
+    assertEquals(1, invocations)
+    verify(fixture.transport, times(1)).send(any(), anyOrNull())
+  }
+
   @Test
   fun `beforeEnvelopeCallback may fail, but the transport is still sends the envelope `() {
     val sut = fixture.getSut { options ->
@@ -3450,6 +3590,24 @@ class SentryClientTest {
     assertFalse(called)
   }
 
+  @Test
+  fun `when beforeErrorSampling captures another event, the nested capture is dropped and does not recurse`() {
+    var invocations = 0
+    lateinit var sut: SentryClient
+    fixture.sentryOptions.sessionReplay.beforeErrorSampling =
+      SentryReplayOptions.BeforeErrorSamplingCallback { _, _ ->
+        invocations++
+        sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) })
+        true
+      }
+    sut = fixture.getSut()
+
+    sut.captureEvent(SentryEvent().apply { exceptions = listOf(SentryException()) })
+
+    assertEquals(1, invocations)
+    verify(fixture.transport, times(1)).send(any(), anyOrNull())
+  }
+
   @Test
   fun `beforeErrorSampling returning false skips captureReplay`() {
     var called = false

From 7f6421dfb157952bcce5e5e07189bd3b05aad8c4 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 21 Jul 2026 10:55:29 +0200
Subject: [PATCH 309/391] chore(deps): bump actions/checkout in the
 github-actions group (#5794)

Bumps the github-actions group with 1 update: [actions/checkout](https://github.com/actions/checkout).


Updates `actions/checkout` from 7.0.0 to 7.0.1
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0...3d3c42e5aac5ba805825da76410c181273ba90b1)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: 7.0.1
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/changes-in-high-risk-code.yml     | 2 +-
 .github/workflows/check-tombstone-proto-schema.yml  | 2 +-
 .github/workflows/codeql-analysis.yml               | 2 +-
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 4 ++--
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/release.yml                       | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 18 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 5251236fd54..e3ec972ffe6 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -28,7 +28,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 4ab77129172..04b5d26e6c2 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -19,7 +19,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           ref: ${{ github.event.pull_request.head.sha || github.sha }}
           submodules: 'recursive'
diff --git a/.github/workflows/changes-in-high-risk-code.yml b/.github/workflows/changes-in-high-risk-code.yml
index 864be8140ad..44d65924209 100644
--- a/.github/workflows/changes-in-high-risk-code.yml
+++ b/.github/workflows/changes-in-high-risk-code.yml
@@ -16,7 +16,7 @@ jobs:
       high_risk_code: ${{ steps.changes.outputs.high_risk_code }}
       high_risk_code_files: ${{ steps.changes.outputs.high_risk_code_files }}
     steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
       - name: Get changed files
         id: changes
         uses: dorny/paths-filter@7b450fff21473bca461d4b92ce414b9d0420d706 # v4.0.2
diff --git a/.github/workflows/check-tombstone-proto-schema.yml b/.github/workflows/check-tombstone-proto-schema.yml
index 3e30f97e45e..0190865250e 100644
--- a/.github/workflows/check-tombstone-proto-schema.yml
+++ b/.github/workflows/check-tombstone-proto-schema.yml
@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Check for newer Tombstone proto schema
         run: ./scripts/check-tombstone-proto-schema.sh
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index ef7e91d8cfb..919d09659b9 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index a5aee08bceb..dcb0ca09dbe 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -20,7 +20,7 @@ jobs:
           java-version: '17'
 
       - name: Checkout
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       # TODO: remove this when upstream is fixed
       - name: Disable Gradle configuration cache (see https://github.com/fossas/fossa-cli/issues/872)
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index 21b7373a361..c0ca07b7387 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index e987a0eedbf..72d7e9dd7c5 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout 🛎️
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index ab6c3de9bcf..6b0c074f9da 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -27,7 +27,7 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
@@ -77,7 +77,7 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index f72a221e00f..835019d1f89 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Setup Java Version
         uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index fff6ef6fa38..d858ef8c4b2 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -27,7 +27,7 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Set up Java 17
         uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
@@ -77,7 +77,7 @@ jobs:
             arch: x86_64
     steps:
       - name: Checkout code
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Enable KVM
         run: |
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index bd5995e57dd..da46b859a14 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -22,7 +22,7 @@ jobs:
 
     steps:
       - name: Git checkout
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 4d213470aed..32451c1a8cb 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -15,7 +15,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 51e9987cc19..85850dd578b 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -27,7 +27,7 @@ jobs:
         with:
           app-id: ${{ vars.SENTRY_RELEASE_BOT_CLIENT_ID }}
           private-key: ${{ secrets.SENTRY_RELEASE_BOT_PRIVATE_KEY }}
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           token: ${{ steps.token.outputs.token }}
           # Needs to be set, otherwise git describe --tags will fail with: No names found, cannot describe anything
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index aa0c66f9562..d41de896e24 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 24e86afbc04..539301099d7 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 6a6dda337f1..cd12cb80809 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - name: Checkout Repo
-        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index feac0a4f3a7..db1a29df14e 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -98,7 +98,7 @@ jobs:
             agent: "false"
             agent-auto-init: "true"
     steps:
-      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           submodules: 'recursive'
 

From 0da3c81b10da505155ac17e2559677fb22edf442 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 21 Jul 2026 11:58:05 +0200
Subject: [PATCH 310/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.15.4 (#5793)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 ++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6d37da44d4b..4bbee5bf70a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,12 @@
 - Prevent a `StackOverflowError` when a `beforeSend`, `beforeBreadcrumb`, `beforeSendLog`, or `beforeEnvelope` callback triggers another capture (directly or through a logging integration such as Timber) ([#5737](https://github.com/getsentry/sentry-java/pull/5737))
   - Captures made from within a user callback (event, transaction, breadcrumb, log, envelope, or check-in) are now dropped while that callback runs, instead of recursing. Captures made by event processors are unaffected.
 
+### Dependencies
+
+- Bump Native SDK from v0.15.3 to v0.15.4 ([#5793](https://github.com/getsentry/sentry-java/pull/5793))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0154)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.15.3...0.15.4)
+
 ## 8.49.0
 
 ### Features
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 1fd275d06f8..cdbb4326e9c 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -169,7 +169,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.3" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.4" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 0e948652b09b858c7c0c146c4f93657a495b0152 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 21 Jul 2026 13:56:01 +0200
Subject: [PATCH 311/391] build: Bump AGP to 9.2.1 and migrate Android modules
 (JAVA-649) (#5779)

Raise the minimum AGP to 9.0.0 (default fallback 9.2.1) and perform the
AGP 9 migration: refresh the AGP-compat matrix (9.0.0/9.1.1/9.2.1), add
the AGP 9 opt-outs (android.builtInKotlin/newDsl, lint 9.2.1), pin Java
and Kotlin targets to 8 across the Android library modules, set
testBuildType to release for unit tests (including sentry-compose), bump
the uitest modules to JVM 11, and resolve the AGP 9.2 lint findings.

Robolectric 4.15 caps at API 35, so pin the affected tests with
@Config(sdk = [35]) to keep them green against targetSdk 36. lint 9.2.1
flags compileSdk 36 as outdated (37 is available); disable GradleDependency
for the Android modules since the SDK bump lives in the API 37 PR.

Split out from the API 37 bump (#5768) so the toolchain upgrade lands on
its own. compileSdk/targetSdk stay at 36 here.




Claude-Session: https://claude.ai/code/session_01EmE8hdaj9H9K61opK2PZ6U

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 .github/workflows/agp-matrix.yml              |  2 +-
 CHANGELOG.md                                  |  4 +++
 build.gradle.kts                              | 26 +++++++++++++++++++
 buildSrc/src/main/java/Config.kt              |  2 +-
 gradle.properties                             |  5 +++-
 sentry-android-core/build.gradle.kts          |  7 ++++-
 .../util/SentryFrameMetricsCollector.java     |  2 +-
 .../layout/sentry_dialog_user_feedback.xml    |  3 +++
 sentry-android-distribution/build.gradle.kts  |  7 ++++-
 .../distribution/UpdateResponseParserTest.kt  |  2 ++
 sentry-android-fragment/build.gradle.kts      | 12 ++++++---
 .../build.gradle.kts                          |  5 ++--
 .../build.gradle.kts                          |  3 ++-
 .../build.gradle.kts                          |  4 ++-
 .../sentry-uitest-android/build.gradle.kts    |  6 +++--
 sentry-android-navigation/build.gradle.kts    | 12 ++++++---
 sentry-android-ndk/build.gradle.kts           |  4 +++
 sentry-android-replay/build.gradle.kts        | 17 +++++++-----
 .../android/replay/ScreenshotRecorderTest.kt  |  2 ++
 .../sentry/android/replay/util/ViewsTest.kt   |  2 ++
 sentry-android-sqlite/build.gradle.kts        | 12 ++++++---
 sentry-android-timber/build.gradle.kts        | 12 ++++++---
 sentry-apache-http-client-5/build.gradle.kts  | 11 ++++----
 sentry-compose/build.gradle.kts               |  6 +++--
 sentry-launchdarkly-android/build.gradle.kts  |  4 +++
 settings.gradle.kts                           |  1 +
 26 files changed, 135 insertions(+), 38 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index e3ec972ffe6..513d879513f 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -17,7 +17,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        agp: [ '8.7.0','8.8.0','8.9.0' ]
+        agp: [ '9.0.0', '9.1.1', '9.2.1' ]
         integrations: [ true, false ]
 
     name: AGP Matrix Release - AGP ${{ matrix.agp }} - Integrations ${{ matrix.integrations }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4bbee5bf70a..df9e9e3c0c2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,10 @@
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0154)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.15.3...0.15.4)
 
+### Dependencies
+
+- The SDK is now compiled with Android Gradle Plugin 9.2.1 ([#5779](https://github.com/getsentry/sentry-java/pull/5779))
+
 ## 8.49.0
 
 ### Features
diff --git a/build.gradle.kts b/build.gradle.kts
index 55b5a71a1e5..2e491d2a16c 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -113,6 +113,20 @@ allprojects {
 subprojects {
     apply { plugin("io.sentry.spotless") }
 
+    // AGP 9.2 bundles lint 9.2.1, which flags compileSdk 36 as outdated because 37 is available.
+    // We intentionally stay on compileSdk 36 until the API 37 bump (#5768), so silence that check
+    // for every Android module (library and application).
+    pluginManager.withPlugin("com.android.library") {
+        extensions.configure<com.android.build.gradle.BaseExtension> {
+            lintOptions { disable("GradleDependency") }
+        }
+    }
+    pluginManager.withPlugin("com.android.application") {
+        extensions.configure<com.android.build.gradle.BaseExtension> {
+            lintOptions { disable("GradleDependency") }
+        }
+    }
+
     plugins.withId(Config.QualityPlugins.detektPlugin) {
         configure<DetektExtension> {
             buildUponDefaultConfig = true
@@ -168,6 +182,18 @@ subprojects {
             }
         }
 
+        // AGP 9 defaults Android modules to Java 11. Pin the published library modules back
+        // to Java 8 so their bytecode stays consumable by Java 8 projects, mirroring the
+        // java-library pin above.
+        plugins.withId("com.android.library") {
+            configure<com.android.build.gradle.BaseExtension> {
+                compileOptions {
+                    sourceCompatibility = JavaVersion.VERSION_1_8
+                    targetCompatibility = JavaVersion.VERSION_1_8
+                }
+            }
+        }
+
         apply<MavenPublishPlugin>()
 
         afterEvaluate {
diff --git a/buildSrc/src/main/java/Config.kt b/buildSrc/src/main/java/Config.kt
index f0e2e9baf86..7575670a38a 100644
--- a/buildSrc/src/main/java/Config.kt
+++ b/buildSrc/src/main/java/Config.kt
@@ -1,6 +1,6 @@
 
 object Config {
-    val AGP = System.getenv("VERSION_AGP") ?: "8.13.1"
+    val AGP = System.getenv("VERSION_AGP") ?: "9.2.1"
     val kotlinStdLib = "stdlib-jdk8"
     val kotlinStdLibVersionAndroid = "1.9.24"
     val kotlinTestJunit = "test-junit"
diff --git a/gradle.properties b/gradle.properties
index aa5a7b1e28d..edb73d3fb78 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -10,7 +10,10 @@ org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
 
 # AndroidX required by AGP >= 3.6.x
 android.useAndroidX=true
-android.experimental.lint.version=8.13.1
+# AGP 9+ migration opt-outs until we remove kotlin-android plugin and adopt built-in Kotlin.
+android.builtInKotlin=false
+android.newDsl=false
+android.experimental.lint.version=9.2.1
 
 # Release information
 versionName=8.49.0
diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index 0388b7de486..f92876530fd 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -1,5 +1,6 @@
 import net.ltgt.gradle.errorprone.errorprone
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
 
 plugins {
   id("com.android.library")
@@ -33,7 +34,11 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8 }
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
+  kotlin { compilerOptions.jvmTarget = JVM_1_8 }
 
   testOptions {
     animationsDisabled = true
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
index 4f76a51e86f..4f6b486f3a1 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
@@ -91,7 +91,7 @@ public SentryFrameMetricsCollector(
   }
 
   @SuppressWarnings("deprecation")
-  @SuppressLint({"NewApi", "PrivateApi"})
+  @SuppressLint({"NewApi", "PrivateApi", "DiscouragedPrivateApi"})
   public SentryFrameMetricsCollector(
       final @NotNull Context context,
       final @NotNull ILogger logger,
diff --git a/sentry-android-core/src/main/res/layout/sentry_dialog_user_feedback.xml b/sentry-android-core/src/main/res/layout/sentry_dialog_user_feedback.xml
index 722a0d5cf3d..370c37fa0e9 100644
--- a/sentry-android-core/src/main/res/layout/sentry_dialog_user_feedback.xml
+++ b/sentry-android-core/src/main/res/layout/sentry_dialog_user_feedback.xml
@@ -47,6 +47,7 @@
         android:layout_height="wrap_content"
         android:hint="Your Name"
         android:inputType="textPersonName"
+        android:autofillHints="name"
         android:background="@drawable/sentry_edit_text_border"
         android:paddingHorizontal="8dp"
         android:layout_below="@id/sentry_dialog_user_feedback_txt_name" />
@@ -66,6 +67,7 @@
         android:layout_height="wrap_content"
         android:hint="your.email@example.org"
         android:inputType="textEmailAddress"
+        android:autofillHints="emailAddress"
         android:background="@drawable/sentry_edit_text_border"
         android:paddingHorizontal="8dp"
         android:layout_below="@id/sentry_dialog_user_feedback_txt_email" />
@@ -85,6 +87,7 @@
         android:layout_height="wrap_content"
         android:lines="6"
         android:inputType="textMultiLine"
+        android:importantForAutofill="no"
         android:gravity="top|left"
         android:hint="What's the bug? What did you expect?"
         android:background="@drawable/sentry_edit_text_border"
diff --git a/sentry-android-distribution/build.gradle.kts b/sentry-android-distribution/build.gradle.kts
index 2d23bf3ab74..363bce003f4 100644
--- a/sentry-android-distribution/build.gradle.kts
+++ b/sentry-android-distribution/build.gradle.kts
@@ -1,3 +1,4 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
 import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
 plugins {
@@ -12,6 +13,10 @@ android {
   defaultConfig { minSdk = libs.versions.minSdk.get().toInt() }
   buildFeatures { buildConfig = false }
 
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
   testOptions {
     unitTests.apply {
       isReturnDefaultValues = true
@@ -21,7 +26,7 @@ android {
 }
 
 kotlin {
-  jvmToolchain(17)
+  compilerOptions.jvmTarget = JVM_1_8
   compilerOptions.languageVersion = KotlinVersion.KOTLIN_1_9
   explicitApi()
 }
diff --git a/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt b/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt
index 3f1d083919c..f1817a39f34 100644
--- a/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt
+++ b/sentry-android-distribution/src/test/java/io/sentry/android/distribution/UpdateResponseParserTest.kt
@@ -8,8 +8,10 @@ import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
 
 @RunWith(AndroidJUnit4::class)
+@Config(sdk = [35])
 class UpdateResponseParserTest {
 
   private lateinit var options: SentryOptions
diff --git a/sentry-android-fragment/build.gradle.kts b/sentry-android-fragment/build.gradle.kts
index 1bd182d618c..197c0b05d6a 100644
--- a/sentry-android-fragment/build.gradle.kts
+++ b/sentry-android-fragment/build.gradle.kts
@@ -1,4 +1,6 @@
 import io.gitlab.arturbosch.detekt.Detekt
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
 plugins {
   id("com.android.library")
@@ -23,10 +25,14 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
   kotlin {
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
-    compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
-    compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+    compilerOptions.jvmTarget = JvmTarget.JVM_1_8
+    compilerOptions.languageVersion = KotlinVersion.KOTLIN_1_9
+    compilerOptions.apiVersion = KotlinVersion.KOTLIN_1_9
   }
 
   testOptions {
diff --git a/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
index 459c1653fa9..04b5eaf6a23 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
@@ -1,5 +1,6 @@
 import io.gitlab.arturbosch.detekt.Detekt
 import net.ltgt.gradle.errorprone.errorprone
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
   id("com.android.application")
@@ -64,12 +65,12 @@ android {
     }
   }
 
-  kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8 }
+  kotlin { compilerOptions.jvmTarget = JvmTarget.JVM_11 }
 
   lint {
     warningsAsErrors = true
     checkDependencies = true
-    // Suppress OldTargetApi: lint 8.13.1 expects API 37 but we target 36
+    // Suppress OldTargetApi: lint 9.2.1 expects API 37 but we target 36
     disable += "OldTargetApi"
 
     // We run a full lint analysis as build part in CI, so skip vital checks for assemble tasks.
diff --git a/sentry-android-integration-tests/sentry-uitest-android-critical/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android-critical/build.gradle.kts
index 4b0cd68ca90..6f875e7a5e9 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-critical/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android-critical/build.gradle.kts
@@ -1,4 +1,5 @@
 import io.gitlab.arturbosch.detekt.Detekt
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
   id("com.android.application")
@@ -31,7 +32,7 @@ android {
       proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
     }
   }
-  kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8 }
+  kotlin { compilerOptions.jvmTarget = JvmTarget.JVM_11 }
   buildFeatures { compose = true }
   composeOptions { kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get() }
   androidComponents.beforeVariants {
diff --git a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/build.gradle.kts
index 2d2aab48a1b..a00d76d6029 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/build.gradle.kts
@@ -1,3 +1,5 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11
+
 plugins {
   id("com.android.test")
   alias(libs.plugins.kotlin.android)
@@ -30,7 +32,7 @@ android {
     targetCompatibility = JavaVersion.VERSION_11
   }
 
-  kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11 }
+  kotlin { compilerOptions.jvmTarget = JVM_11 }
 
   targetProjectPath = ":sentry-samples:sentry-samples-android"
   // Run the test in its own process so it measures the target app cold, not itself.
diff --git a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
index 1d725b0b595..6fbba814f83 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
@@ -1,5 +1,6 @@
 import io.gitlab.arturbosch.detekt.Detekt
 import net.ltgt.gradle.errorprone.errorprone
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
   id("com.android.application")
@@ -56,18 +57,19 @@ android {
   buildTypes {
     getByName("release") {
       isMinifyEnabled = true
+      isShrinkResources = true
       proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
       signingConfig = signingConfigs.getByName("debug") // to be able to run release mode
       testProguardFiles("proguard-rules.pro")
     }
   }
 
-  kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8 }
+  kotlin { compilerOptions.jvmTarget = JvmTarget.JVM_11 }
 
   lint {
     warningsAsErrors = true
     checkDependencies = true
-    // Suppress OldTargetApi: lint 8.13.1 expects API 37 but we target 36
+    // Suppress OldTargetApi: lint 9.2.1 expects API 37 but we target 36
     disable += "OldTargetApi"
 
     // We run a full lint analysis as build part in CI, so skip vital checks for assemble tasks.
diff --git a/sentry-android-navigation/build.gradle.kts b/sentry-android-navigation/build.gradle.kts
index eaa204b3860..5ac9842548f 100644
--- a/sentry-android-navigation/build.gradle.kts
+++ b/sentry-android-navigation/build.gradle.kts
@@ -1,4 +1,6 @@
 import io.gitlab.arturbosch.detekt.Detekt
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
 plugins {
   id("com.android.library")
@@ -23,10 +25,14 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
   kotlin {
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
-    compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
-    compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+    compilerOptions.jvmTarget = JVM_1_8
+    compilerOptions.languageVersion = KotlinVersion.KOTLIN_1_9
+    compilerOptions.apiVersion = KotlinVersion.KOTLIN_1_9
   }
 
   testOptions {
diff --git a/sentry-android-ndk/build.gradle.kts b/sentry-android-ndk/build.gradle.kts
index c2d0a33d823..ba651da56ac 100644
--- a/sentry-android-ndk/build.gradle.kts
+++ b/sentry-android-ndk/build.gradle.kts
@@ -26,6 +26,10 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
   kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8 }
 
   testOptions {
diff --git a/sentry-android-replay/build.gradle.kts b/sentry-android-replay/build.gradle.kts
index 8d0f63797aa..02f2dab3d4d 100644
--- a/sentry-android-replay/build.gradle.kts
+++ b/sentry-android-replay/build.gradle.kts
@@ -1,4 +1,6 @@
 import io.gitlab.arturbosch.detekt.Detekt
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompilationTask
 
 plugins {
@@ -25,20 +27,21 @@ android {
 
   buildFeatures { compose = true }
 
-  composeOptions {
-    kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get()
-    useLiveLiterals = false
-  }
+  composeOptions { kotlinCompilerExtensionVersion = libs.versions.composeCompiler.get() }
 
   buildTypes {
     getByName("debug") { consumerProguardFiles("proguard-rules.pro") }
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
   kotlin {
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
-    compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
-    compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+    compilerOptions.jvmTarget = JvmTarget.JVM_1_8
+    compilerOptions.languageVersion = KotlinVersion.KOTLIN_1_9
+    compilerOptions.apiVersion = KotlinVersion.KOTLIN_1_9
   }
 
   testOptions {
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ScreenshotRecorderTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ScreenshotRecorderTest.kt
index 2818eeb3537..00b58666669 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ScreenshotRecorderTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ScreenshotRecorderTest.kt
@@ -14,8 +14,10 @@ import kotlin.test.Test
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.kotlin.mock
+import org.robolectric.annotation.Config
 
 @RunWith(AndroidJUnit4::class)
+@Config(sdk = [35])
 class ScreenshotRecorderTest {
 
   internal class Fixture() {
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ViewsTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ViewsTest.kt
index 2eaa8411cfe..3d5f6a9c506 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ViewsTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ViewsTest.kt
@@ -20,8 +20,10 @@ import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.robolectric.Robolectric.buildActivity
 import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
 
 @RunWith(AndroidJUnit4::class)
+@Config(sdk = [35])
 class ViewsTest {
 
   @BeforeTest
diff --git a/sentry-android-sqlite/build.gradle.kts b/sentry-android-sqlite/build.gradle.kts
index 6e0275b29b8..e1e3bc68765 100644
--- a/sentry-android-sqlite/build.gradle.kts
+++ b/sentry-android-sqlite/build.gradle.kts
@@ -1,4 +1,6 @@
 import io.gitlab.arturbosch.detekt.Detekt
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
 plugins {
   id("com.android.library")
@@ -23,10 +25,14 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
   kotlin {
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
-    compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
-    compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+    compilerOptions.jvmTarget = JvmTarget.JVM_1_8
+    compilerOptions.languageVersion = KotlinVersion.KOTLIN_1_9
+    compilerOptions.apiVersion = KotlinVersion.KOTLIN_1_9
   }
 
   testOptions {
diff --git a/sentry-android-timber/build.gradle.kts b/sentry-android-timber/build.gradle.kts
index d8f8431bef1..e55b8b0e3c5 100644
--- a/sentry-android-timber/build.gradle.kts
+++ b/sentry-android-timber/build.gradle.kts
@@ -1,4 +1,6 @@
 import io.gitlab.arturbosch.detekt.Detekt
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
 plugins {
   id("com.android.library")
@@ -30,10 +32,14 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
   kotlin {
-    compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
-    compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
-    compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+    compilerOptions.jvmTarget = JvmTarget.JVM_1_8
+    compilerOptions.languageVersion = KotlinVersion.KOTLIN_1_9
+    compilerOptions.apiVersion = KotlinVersion.KOTLIN_1_9
   }
 
   testOptions {
diff --git a/sentry-apache-http-client-5/build.gradle.kts b/sentry-apache-http-client-5/build.gradle.kts
index 984974bae9a..7502fb6c4b8 100644
--- a/sentry-apache-http-client-5/build.gradle.kts
+++ b/sentry-apache-http-client-5/build.gradle.kts
@@ -1,5 +1,6 @@
 import net.ltgt.gradle.errorprone.errorprone
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
 plugins {
   `java-library`
@@ -10,10 +11,10 @@ plugins {
   alias(libs.plugins.gradle.versions)
 }
 
-tasks.withType<KotlinCompile>().configureEach {
-  compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8
-  compilerOptions.languageVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
-  compilerOptions.apiVersion = org.jetbrains.kotlin.gradle.dsl.KotlinVersion.KOTLIN_1_9
+kotlin {
+  compilerOptions.jvmTarget = JvmTarget.JVM_1_8
+  compilerOptions.languageVersion = KotlinVersion.KOTLIN_1_9
+  compilerOptions.apiVersion = KotlinVersion.KOTLIN_1_9
 }
 
 dependencies {
diff --git a/sentry-compose/build.gradle.kts b/sentry-compose/build.gradle.kts
index c45a431b1b3..388bfe832bb 100644
--- a/sentry-compose/build.gradle.kts
+++ b/sentry-compose/build.gradle.kts
@@ -87,13 +87,15 @@ android {
     buildConfigField("String", "VERSION_NAME", "\"${project.version}\"")
   }
 
-  sourceSets["main"].apply { manifest.srcFile("src/androidMain/AndroidManifest.xml") }
-
   buildTypes {
     getByName("debug") { consumerProguardFiles("proguard-rules.pro") }
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
   testOptions {
     animationsDisabled = true
     unitTests.apply {
diff --git a/sentry-launchdarkly-android/build.gradle.kts b/sentry-launchdarkly-android/build.gradle.kts
index 427ec473676..32b3641203f 100644
--- a/sentry-launchdarkly-android/build.gradle.kts
+++ b/sentry-launchdarkly-android/build.gradle.kts
@@ -27,6 +27,10 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
+  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
+  // variant, so unit tests must target release to run at all.
+  testBuildType = "release"
+
   kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8 }
 
   testOptions {
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 7fb5c627912..82fad42aee3 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -13,6 +13,7 @@ pluginManagement {
     }
     mavenCentral()
     gradlePluginPortal()
+    google()
   }
 }
 

From 8d299fcb84b5afdbc618ece9b25b9a65b917e3eb Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 21 Jul 2026 14:29:45 +0200
Subject: [PATCH 312/391] perf(android): Init shake detector off the main
 thread (#5784)

* perf(android): Init shake detector off the main thread (JAVA-618)

FeedbackShakeIntegration.register() resolved the accelerometer via
SensorManager synchronously on the calling thread, which under auto-init
is the main thread. On a Pixel 10 this first SensorManager access
measured ~1.75ms, making it the single most expensive integration in the
Sentry.init register loop.

Submit the pre-warm init() to the executor service instead. start()
already re-runs the idempotent init() on demand, so shake detection still
works if an activity resumes before the warm-up completes. SentryShakeDetector's
lifecycle methods are now synchronized so the executor warm-up and a
main-thread start() cannot race on the sensor fields.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* docs: Add changelog for shake-detector init off main thread (JAVA-618)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(android): Guard shake detector against warm-up after close (JAVA-618)

A warm-up init submitted to the executor could be drained after the
integration's close() ran, since integrations shut down before the
executor. That re-resolved the sensor and leaked a HandlerThread. Guard
init()/start() with a closed latch so a late warm-up is a no-op.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(android): Re-arm shake detector on re-register (JAVA-618)

The closed latch added to neutralize a warm-up drained after close()
was permanent, so re-registering the same integration (e.g. a second
Sentry.init reusing the same options) left shake detection off with no
recovery. register() now re-arms the detector via reopen(), which the
stale-warm-up path (init()) deliberately does not, preserving the
drain-after-close guard.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../core/FeedbackShakeIntegration.java        | 22 ++++++-
 .../android/core/SentryShakeDetector.java     | 29 +++++++--
 .../core/FeedbackShakeIntegrationTest.kt      | 64 ++++++++++++++++++-
 4 files changed, 108 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index df9e9e3c0c2..41b74388723 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Reduce main-thread work during `Sentry.init` by resolving the shake-detector accelerometer off the main thread (~1.75ms on a Pixel 10) ([#5784](https://github.com/getsentry/sentry-java/pull/5784))
 - Backfill release, environment, distribution, tags, and app version/build—and use the matching replay-on-error sample rate—for `ApplicationExitInfo` ANR and native crash events captured before SDK initialization, without reusing options cached by a later app update ([#5762](https://github.com/getsentry/sentry-java/pull/5762))
 - `SentryTagModifierNode.isImportantForBounds` now matches the default behavior and returns `true` ([#5789](https://github.com/getsentry/sentry-java/pull/5789))
 - Prevent a `StackOverflowError` when a `beforeSend`, `beforeBreadcrumb`, `beforeSendLog`, or `beforeEnvelope` callback triggers another capture (directly or through a logging integration such as Timber) ([#5737](https://github.com/getsentry/sentry-java/pull/5737))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
index fc34f18152f..b059b0104da 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
@@ -44,11 +44,29 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
                 : null,
             "SentryAndroidOptions is required");
 
-    if (!this.options.getFeedbackOptions().isUseShakeGesture()) {
+    final @NotNull SentryAndroidOptions options = this.options;
+
+    if (!options.getFeedbackOptions().isUseShakeGesture()) {
       return;
     }
 
-    shakeDetector.init(application, options.getLogger());
+    // Re-arm the detector in case this integration is being re-registered after a previous close()
+    // (e.g. a second Sentry.init reusing the same options), otherwise the closed latch would keep
+    // shake detection off permanently.
+    shakeDetector.reopen();
+
+    // Resolving the accelerometer is the most expensive part of init (the first SensorManager
+    // access), so warm it up off the main thread. start() re-runs init() on demand, so shake
+    // detection still works if an activity resumes before this completes.
+    try {
+      options
+          .getExecutorService()
+          .submit(() -> shakeDetector.init(application, options.getLogger()));
+    } catch (Throwable t) {
+      options
+          .getLogger()
+          .log(SentryLevel.WARNING, "Failed to submit shake detector initialization.", t);
+    }
 
     addIntegrationToSdkVersion("FeedbackShake");
     application.registerActivityLifecycleCallbacks(this);
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java
index a4c4ae0c4f5..9f4f73d10f4 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryShakeDetector.java
@@ -40,6 +40,7 @@ public final class SentryShakeDetector implements SensorEventListener {
   private @Nullable Handler handler;
   private volatile @Nullable Listener listener;
   private @NotNull ILogger logger;
+  private boolean closed;
 
   private final @NotNull SampleQueue queue = new SampleQueue();
 
@@ -51,16 +52,29 @@ public SentryShakeDetector(final @NotNull ILogger logger) {
     this.logger = logger;
   }
 
+  /**
+   * Re-arms the detector after a previous {@link #close()} so it can be reused when the owning
+   * integration is registered again (e.g. a second {@code Sentry.init}).
+   */
+  synchronized void reopen() {
+    closed = false;
+  }
+
   /**
    * Initializes the sensor manager and accelerometer sensor. This is separated from start() so the
    * values can be resolved once and reused across activity transitions.
    */
-  void init(final @NotNull Context context, final @NotNull ILogger logger) {
+  synchronized void init(final @NotNull Context context, final @NotNull ILogger logger) {
     this.logger = logger;
     init(context);
   }
 
-  private void init(final @NotNull Context context) {
+  private synchronized void init(final @NotNull Context context) {
+    // A warm-up submitted to the executor can be drained after close() (integrations are closed
+    // before the executor shuts down), so bail out instead of spinning up a new HandlerThread.
+    if (closed) {
+      return;
+    }
     if (sensorManager == null) {
       sensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
     }
@@ -74,7 +88,11 @@ private void init(final @NotNull Context context) {
     }
   }
 
-  public void start(final @NotNull Context context, final @NotNull Listener shakeListener) {
+  public synchronized void start(
+      final @NotNull Context context, final @NotNull Listener shakeListener) {
+    if (closed) {
+      return;
+    }
     this.listener = shakeListener;
     init(context);
     if (sensorManager == null) {
@@ -89,7 +107,7 @@ public void start(final @NotNull Context context, final @NotNull Listener shakeL
     sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_NORMAL, handler);
   }
 
-  public void stop() {
+  public synchronized void stop() {
     listener = null;
     if (sensorManager != null) {
       sensorManager.unregisterListener(this);
@@ -105,7 +123,8 @@ public void stop() {
   }
 
   /** Stops detection and releases the background thread. */
-  public void close() {
+  public synchronized void close() {
+    closed = true;
     stop();
     if (handlerThread != null) {
       // quitSafely drains pending messages (including the clear posted by stop) before exiting
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
index bddc9395c0d..170211abf55 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
@@ -2,13 +2,18 @@ package io.sentry.android.core
 
 import android.app.Activity
 import android.app.Application
+import android.content.Context
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.Scopes
 import io.sentry.SentryFeedbackOptions
+import io.sentry.test.DeferredExecutorService
+import io.sentry.test.ImmediateExecutorService
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
+import org.mockito.kotlin.atLeastOnce
+import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
 import org.mockito.kotlin.verify
@@ -20,7 +25,11 @@ class FeedbackShakeIntegrationTest {
   private class Fixture {
     val application = mock<Application>()
     val scopes = mock<Scopes>()
-    val options = SentryAndroidOptions().apply { dsn = "https://key@sentry.io/proj" }
+    val options =
+      SentryAndroidOptions().apply {
+        dsn = "https://key@sentry.io/proj"
+        executorService = ImmediateExecutorService()
+      }
     val activity = mock<Activity>()
     val formHandler = mock<SentryFeedbackOptions.IFormHandler>()
 
@@ -49,6 +58,59 @@ class FeedbackShakeIntegrationTest {
     verify(fixture.application).registerActivityLifecycleCallbacks(any())
   }
 
+  @Test
+  fun `resolves the accelerometer sensor off the main thread`() {
+    val deferredExecutor = DeferredExecutorService()
+    fixture.options.executorService = deferredExecutor
+    whenever(fixture.application.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    // Callback registration stays synchronous, but the expensive SensorManager lookup is deferred.
+    verify(fixture.application).registerActivityLifecycleCallbacks(any())
+    verify(fixture.application, never()).getSystemService(eq(Context.SENSOR_SERVICE))
+
+    deferredExecutor.runAll()
+
+    verify(fixture.application).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `warm-up drained after close does not resolve the sensor`() {
+    // Integrations are closed before the executor drains, so a queued warm-up can run after
+    // close(). It must be a no-op rather than resolving the sensor and spinning up a HandlerThread.
+    val deferredExecutor = DeferredExecutorService()
+    fixture.options.executorService = deferredExecutor
+    whenever(fixture.application.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+    sut.close()
+
+    deferredExecutor.runAll()
+
+    verify(fixture.application, never()).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `re-registering after close re-arms shake detection`() {
+    // A second Sentry.init reusing the same integration must revive shake detection rather than
+    // stay off because of the closed latch.
+    val deferredExecutor = DeferredExecutorService()
+    fixture.options.executorService = deferredExecutor
+    whenever(fixture.application.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+    sut.close()
+    sut.register(fixture.scopes, fixture.options)
+
+    deferredExecutor.runAll()
+
+    verify(fixture.application, atLeastOnce()).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
   @Test
   fun `when useShakeGesture is disabled does not register activity lifecycle callbacks`() {
     val sut = fixture.getSut(useShakeGesture = false)

From 5e269decf0940fea3ca550fb708cdeaa556bd72b Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 21 Jul 2026 15:06:44 +0200
Subject: [PATCH 313/391] ci(android): Bump Maestro to 2.7.0 for UI critical
 tests (#5798)

Update the pinned Maestro CLI version used by the UI critical
integration tests from 2.1.0 to the latest 2.7.0. No flow changes
are required; all commands used remain supported and the Java 17
requirement is already satisfied by the CI job.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index d858ef8c4b2..f1f8e29a3a9 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -15,7 +15,7 @@ env:
   BUILD_PATH: "build/outputs/apk/release"
   APK_NAME: "sentry-uitest-android-critical-release.apk"
   APK_ARTIFACT_NAME: "sentry-uitest-android-critical-release"
-  MAESTRO_VERSION: "2.1.0"
+  MAESTRO_VERSION: "2.7.0"
 
 jobs:
   build:

From e82419da4ab49467d1cb6d41ebd9674123746230 Mon Sep 17 00:00:00 2001
From: Syed Arsalan Hasan <sahasan.95@gmail.com>
Date: Wed, 22 Jul 2026 10:36:02 +0500
Subject: [PATCH 314/391] Replace deprecated ThrowableProxy with
 LogEvent#getThrown() in sentry-log4j2 (#5751)

* Replace deprecated ThrowableProxy with LogEvent#getThrown() in sentry-log4j2

* Add @Nullable annotation and CHANGELOG entry

---------

Co-authored-by: Alexander Dinauer <adinauer@users.noreply.github.com>
---
 CHANGELOG.md                                              | 1 +
 .../src/main/java/io/sentry/log4j2/SentryAppender.java    | 8 +++-----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 41b74388723..88bc0c7e11a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@
 - `SentryTagModifierNode.isImportantForBounds` now matches the default behavior and returns `true` ([#5789](https://github.com/getsentry/sentry-java/pull/5789))
 - Prevent a `StackOverflowError` when a `beforeSend`, `beforeBreadcrumb`, `beforeSendLog`, or `beforeEnvelope` callback triggers another capture (directly or through a logging integration such as Timber) ([#5737](https://github.com/getsentry/sentry-java/pull/5737))
   - Captures made from within a user callback (event, transaction, breadcrumb, log, envelope, or check-in) are now dropped while that callback runs, instead of recursing. Captures made by event processors are unaffected.
+- Replace deprecated `ThrowableProxy` with `LogEvent#getThrown()` in `sentry-log4j2` ([#5751](https://github.com/getsentry/sentry-java/pull/5751))
 
 ### Dependencies
 
diff --git a/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java b/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java
index df0f9eeb2d2..0218b53518d 100644
--- a/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java
+++ b/sentry-log4j2/src/main/java/io/sentry/log4j2/SentryAppender.java
@@ -41,7 +41,6 @@
 import org.apache.logging.log4j.core.config.plugins.PluginAttribute;
 import org.apache.logging.log4j.core.config.plugins.PluginElement;
 import org.apache.logging.log4j.core.config.plugins.PluginFactory;
-import org.apache.logging.log4j.core.impl.ThrowableProxy;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -274,13 +273,12 @@ protected void captureLog(@NotNull LogEvent loggingEvent) {
     event.setLogger(loggingEvent.getLoggerName());
     event.setLevel(formatLevel(loggingEvent.getLevel()));
 
-    final ThrowableProxy throwableInformation = loggingEvent.getThrownProxy();
-    if (throwableInformation != null) {
+    final @Nullable Throwable thrown = loggingEvent.getThrown();
+    if (thrown != null) {
       final Mechanism mechanism = new Mechanism();
       mechanism.setType(MECHANISM_TYPE);
       final Throwable mechanismException =
-          new ExceptionMechanismException(
-              mechanism, throwableInformation.getThrowable(), Thread.currentThread());
+          new ExceptionMechanismException(mechanism, thrown, Thread.currentThread());
       event.setThrowable(mechanismException);
     }
 

From ae3e4c77308222ce6a67789896e235d08036f638 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 22 Jul 2026 11:14:43 +0200
Subject: [PATCH 315/391] ci: Add Android 37 emulator to critical UI test
 matrix (JAVA-647) (#5775)

Add an API level 37 (Android 17) emulator to the critical UI test matrix.
API 37 ships only as a minor-versioned image, so the api-level is "37.0"
(the platform and system image packages are android-37.0, not android-37)
and only as google_apis_ps16k; there is no plain google_apis image.

The runner's preinstalled avdmanager is too old to parse the minor version
and writes target=android-0 into the AVD config, so the emulator clamps to
API 3 and boots misconfigured. Update cmdline-tools before creating the AVD,
and key the AVD cache on the tools version to invalidate broken caches.

Workaround from ReactiveCircus/android-emulator-runner#482.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../integration-tests-ui-critical.yml         | 24 ++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index f1f8e29a3a9..1d054079f1d 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -75,6 +75,10 @@ jobs:
             target: google_apis
             channel: canary # Necessary for ATDs
             arch: x86_64
+          - api-level: "37.0" # Android 17; API 37 ships only as a minor-versioned image
+            target: google_apis_ps16k # API 37 has no plain google_apis image
+            channel: canary # Necessary for ATDs
+            arch: x86_64
     steps:
       - name: Checkout code
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -85,6 +89,22 @@ jobs:
           sudo udevadm control --reload-rules
           sudo udevadm trigger --name-match=kvm
 
+      # The runner ships an outdated avdmanager that writes target=android-0 into the
+      # AVD config for minor-versioned packages (android-37.x), so the emulator clamps
+      # to API 3 and boots misconfigured. Update cmdline-tools so avdmanager parses it.
+      # See https://github.com/ReactiveCircus/android-emulator-runner/issues/482
+      - name: Update SDK cmdline-tools
+        id: cmdline-tools
+        run: |
+          SDK="${ANDROID_HOME:-${ANDROID_SDK_ROOT:-/usr/local/lib/android/sdk}}"
+          yes | "$SDK/cmdline-tools/latest/bin/sdkmanager" --install "cmdline-tools;latest" > /dev/null
+          # sdkmanager won't overwrite the preinstalled dir, so it installs to latest-2.
+          if [ -d "$SDK/cmdline-tools/latest-2" ]; then
+            rm -rf "$SDK/cmdline-tools/latest"
+            mv "$SDK/cmdline-tools/latest-2" "$SDK/cmdline-tools/latest"
+          fi
+          echo "version=$("$SDK/cmdline-tools/latest/bin/sdkmanager" --version 2>/dev/null | grep -Eo '^[0-9][0-9.]*' | head -1)" >> "$GITHUB_OUTPUT"
+
       - name: AVD cache
         uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
         id: avd-cache
@@ -92,7 +112,9 @@ jobs:
           path: |
             ~/.android/avd/*
             ~/.android/adb*
-          key: avd-api-${{ matrix.api-level }}-${{ matrix.arch }}-${{ matrix.target }}
+          # Keyed on the cmdline-tools version so AVDs created by the old, broken
+          # avdmanager are invalidated automatically.
+          key: avd-api-${{ matrix.api-level }}-${{ matrix.arch }}-${{ matrix.target }}-tools${{ steps.cmdline-tools.outputs.version }}
 
       - name: Create AVD and generate snapshot for caching
         if: steps.avd-cache.outputs.cache-hit != 'true'

From 5f42ae8d2b9df4994b23fcfd34c28cee2c4f8dab Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 22 Jul 2026 13:25:28 +0200
Subject: [PATCH 316/391] chore(changelog): Merge duplicate Dependencies
 subsections under Unreleased (#5815)

The Unreleased section contained two separate "### Dependencies"
subsections, one added by #5793 and one by #5779. Merge them into a
single subsection, keeping both entries.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 CHANGELOG.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 88bc0c7e11a..1a72ca9eea1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,9 +16,6 @@
 - Bump Native SDK from v0.15.3 to v0.15.4 ([#5793](https://github.com/getsentry/sentry-java/pull/5793))
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0154)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.15.3...0.15.4)
-
-### Dependencies
-
 - The SDK is now compiled with Android Gradle Plugin 9.2.1 ([#5779](https://github.com/getsentry/sentry-java/pull/5779))
 
 ## 8.49.0

From df6bed6ee22dd7e5f3970c570e9062657ffa8a67 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 22 Jul 2026 15:28:52 +0200
Subject: [PATCH 317/391] build: Bump target and compile SDK to 37 (JAVA-648)
 (#5796)

* build: Bump target and compile SDK to 37

Raise targetSdk and compileSdk from 36 to 37 and remove the temporary
GradleDependency lint suppression that was in place only until this bump.

API 37 makes MediaCodecInfo.getVideoCapabilities() nullable, so guard the
access in SimpleVideoEncoder to keep it compiling.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

* build: Drop obsolete OldTargetApi lint suppression

Now that the integration test modules target API 37, lint no longer flags
OldTargetApi, so remove the temporary suppression added while they were on 36.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                       |  1 +
 build.gradle.kts                                   | 14 --------------
 gradle/libs.versions.toml                          |  4 ++--
 .../build.gradle.kts                               |  2 --
 .../sentry-uitest-android/build.gradle.kts         |  2 --
 .../android/replay/video/SimpleVideoEncoder.kt     |  2 +-
 6 files changed, 4 insertions(+), 21 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1a72ca9eea1..96d23812cc6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,7 @@
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0154)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.15.3...0.15.4)
 - The SDK is now compiled with Android Gradle Plugin 9.2.1 ([#5779](https://github.com/getsentry/sentry-java/pull/5779))
+- The SDK has been fully tested for compatibility with Android 17 and platform 37; it is now compiled and tested against it ([#5796](https://github.com/getsentry/sentry-java/pull/5796))
 
 ## 8.49.0
 
diff --git a/build.gradle.kts b/build.gradle.kts
index 2e491d2a16c..764667ecd65 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -113,20 +113,6 @@ allprojects {
 subprojects {
     apply { plugin("io.sentry.spotless") }
 
-    // AGP 9.2 bundles lint 9.2.1, which flags compileSdk 36 as outdated because 37 is available.
-    // We intentionally stay on compileSdk 36 until the API 37 bump (#5768), so silence that check
-    // for every Android module (library and application).
-    pluginManager.withPlugin("com.android.library") {
-        extensions.configure<com.android.build.gradle.BaseExtension> {
-            lintOptions { disable("GradleDependency") }
-        }
-    }
-    pluginManager.withPlugin("com.android.application") {
-        extensions.configure<com.android.build.gradle.BaseExtension> {
-            lintOptions { disable("GradleDependency") }
-        }
-    }
-
     plugins.withId(Config.QualityPlugins.detektPlugin) {
         configure<DetektExtension> {
             buildUponDefaultConfig = true
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index cdbb4326e9c..89de8fce039 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -47,8 +47,8 @@ springboot4 = "4.1.0"
 sqldelight = "2.3.2"
 
 # Android
-targetSdk = "36"
-compileSdk = "36"
+targetSdk = "37"
+compileSdk = "37"
 minSdk = "21"
 
 [plugins]
diff --git a/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
index 04b5eaf6a23..c3ca2379a76 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android-benchmark/build.gradle.kts
@@ -70,8 +70,6 @@ android {
   lint {
     warningsAsErrors = true
     checkDependencies = true
-    // Suppress OldTargetApi: lint 9.2.1 expects API 37 but we target 36
-    disable += "OldTargetApi"
 
     // We run a full lint analysis as build part in CI, so skip vital checks for assemble tasks.
     checkReleaseBuilds = false
diff --git a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
index 6fbba814f83..52c17199e4d 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
+++ b/sentry-android-integration-tests/sentry-uitest-android/build.gradle.kts
@@ -69,8 +69,6 @@ android {
   lint {
     warningsAsErrors = true
     checkDependencies = true
-    // Suppress OldTargetApi: lint 9.2.1 expects API 37 but we target 36
-    disable += "OldTargetApi"
 
     // We run a full lint analysis as build part in CI, so skip vital checks for assemble tasks.
     checkReleaseBuilds = false
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
index de14aadaaab..04d573d793f 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
@@ -81,7 +81,7 @@ internal class SimpleVideoEncoder(
         val videoCapabilities =
           mediaCodec.codecInfo.getCapabilitiesForType(muxerConfig.mimeType).videoCapabilities
 
-        if (!videoCapabilities.bitrateRange.contains(bitRate)) {
+        if (videoCapabilities != null && !videoCapabilities.bitrateRange.contains(bitRate)) {
           options.logger.log(
             DEBUG,
             "Encoder doesn't support the provided bitRate: $bitRate, the value will be clamped to the closest one",

From aafebb3a66d9c7f9273dbbc8517f925b0837ed9c Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 22 Jul 2026 16:31:58 +0200
Subject: [PATCH 318/391] docs(changelog): Add dedicated Android 17 support
 section (#5820)

Promote the Android 17 compatibility note out of the Dependencies
subsection into its own highlighted section so the officially supported
platform is more visible to users reading the changelog.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 96d23812cc6..b9f7fc811bc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Android 17 support
+
+- We've put Android 17 through a set of rigorous tests. We're now officially giving it the Sentry stamp of compatibility .([#5796](https://github.com/getsentry/sentry-java/pull/5796))
+
 ### Fixes
 
 - Reduce main-thread work during `Sentry.init` by resolving the shake-detector accelerometer off the main thread (~1.75ms on a Pixel 10) ([#5784](https://github.com/getsentry/sentry-java/pull/5784))
@@ -17,7 +21,6 @@
   - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0154)
   - [diff](https://github.com/getsentry/sentry-native/compare/0.15.3...0.15.4)
 - The SDK is now compiled with Android Gradle Plugin 9.2.1 ([#5779](https://github.com/getsentry/sentry-java/pull/5779))
-- The SDK has been fully tested for compatibility with Android 17 and platform 37; it is now compiled and tested against it ([#5796](https://github.com/getsentry/sentry-java/pull/5796))
 
 ## 8.49.0
 

From c0eb80252d73405b2a6bd1f84a9d0882fc6bc773 Mon Sep 17 00:00:00 2001
From: runningcode <332597+runningcode@users.noreply.github.com>
Date: Wed, 22 Jul 2026 14:37:22 +0000
Subject: [PATCH 319/391] release: 8.50.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b9f7fc811bc..6accb560053 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.50.0
 
 ### Android 17 support
 
diff --git a/gradle.properties b/gradle.properties
index edb73d3fb78..669629ea17f 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -16,7 +16,7 @@ android.newDsl=false
 android.experimental.lint.version=9.2.1
 
 # Release information
-versionName=8.49.0
+versionName=8.50.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 023ef00380c20af75e4205b5ed82b37a04f22950 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 22 Jul 2026 18:00:41 +0200
Subject: [PATCH 320/391] perf: Schedule session end on shared executor
 (JAVA-653) (#5819)

* perf: Schedule session end on shared executor (JAVA-653)

LifecycleWatcher created a java.util.Timer whose thread was spawned on
the first background transition and lived for the rest of the process.
Schedule the session-end task on the shared timer executor instead,
whose single worker thread is reused and self-terminates when idle. If
scheduling fails (executor already shut down), the session is ended
right away instead of leaking.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  6 ++
 .../sentry/android/core/LifecycleWatcher.java | 60 ++++++++++---------
 .../android/core/LifecycleWatcherTest.kt      | 15 ++---
 3 files changed, 42 insertions(+), 39 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6accb560053..9e1561ebfa3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Performance
+
+- Reduce the number of SDK threads: `LifecycleWatcher` now schedules the session-end task on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5819](https://github.com/getsentry/sentry-java/pull/5819))
+
 ## 8.50.0
 
 ### Android 17 support
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/LifecycleWatcher.java b/sentry-android-core/src/main/java/io/sentry/android/core/LifecycleWatcher.java
index 3d4cedb1b53..de1c40c570c 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/LifecycleWatcher.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/LifecycleWatcher.java
@@ -8,9 +8,7 @@
 import io.sentry.transport.CurrentDateProvider;
 import io.sentry.transport.ICurrentDateProvider;
 import io.sentry.util.AutoClosableReentrantLock;
-import io.sentry.util.LazyEvaluator;
-import java.util.Timer;
-import java.util.TimerTask;
+import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicLong;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -22,9 +20,8 @@ final class LifecycleWatcher implements AppState.AppStateListener {
 
   private final long sessionIntervalMillis;
 
-  private @Nullable TimerTask timerTask;
-  private final @NotNull LazyEvaluator<Timer> timer = new LazyEvaluator<>(() -> new Timer(true));
-  private final @NotNull AutoClosableReentrantLock timerLock = new AutoClosableReentrantLock();
+  private @Nullable Future<?> endSessionFuture;
+  private final @NotNull AutoClosableReentrantLock endSessionLock = new AutoClosableReentrantLock();
   private final @NotNull IScopes scopes;
   private final boolean enableSessionTracking;
   private final boolean enableAppLifecycleBreadcrumbs;
@@ -104,29 +101,40 @@ public void onBackground() {
   }
 
   private void scheduleEndSession() {
-    try (final @NotNull ISentryLifecycleToken ignored = timerLock.acquire()) {
+    try (final @NotNull ISentryLifecycleToken ignored = endSessionLock.acquire()) {
       cancelTask();
-      timerTask =
-          new TimerTask() {
-            @Override
-            public void run() {
-              if (enableSessionTracking) {
-                scopes.endSession();
-              }
-              scopes.getOptions().getReplayController().stop();
-              scopes.getOptions().getContinuousProfiler().close(false);
+      final @NotNull Runnable endSession =
+          () -> {
+            if (enableSessionTracking) {
+              scopes.endSession();
             }
+            scopes.getOptions().getReplayController().stop();
+            scopes.getOptions().getContinuousProfiler().close(false);
           };
 
-      timer.getValue().schedule(timerTask, sessionIntervalMillis);
+      try {
+        endSessionFuture =
+            scopes
+                .getOptions()
+                .getTimerExecutorService()
+                .schedule(endSession, sessionIntervalMillis);
+      } catch (Throwable e) {
+        scopes
+            .getOptions()
+            .getLogger()
+            .log(SentryLevel.WARNING, "Failed to schedule end of session. Ending it now.", e);
+        // if we cannot re-check after the session interval, end the session right away instead of
+        // leaving it open forever
+        endSession.run();
+      }
     }
   }
 
   private void cancelTask() {
-    try (final @NotNull ISentryLifecycleToken ignored = timerLock.acquire()) {
-      if (timerTask != null) {
-        timerTask.cancel();
-        timerTask = null;
+    try (final @NotNull ISentryLifecycleToken ignored = endSessionLock.acquire()) {
+      if (endSessionFuture != null) {
+        endSessionFuture.cancel(false);
+        endSessionFuture = null;
       }
     }
   }
@@ -144,13 +152,7 @@ private void addAppBreadcrumb(final @NotNull String state) {
 
   @TestOnly
   @Nullable
-  TimerTask getTimerTask() {
-    return timerTask;
-  }
-
-  @TestOnly
-  @NotNull
-  Timer getTimer() {
-    return timer.getValue();
+  Future<?> getEndSessionFuture() {
+    return endSessionFuture;
   }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt
index 09c4fae8dc4..ce518eabb05 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/LifecycleWatcherTest.kt
@@ -7,6 +7,7 @@ import io.sentry.IScope
 import io.sentry.IScopes
 import io.sentry.ReplayController
 import io.sentry.ScopeCallback
+import io.sentry.SentryExecutorService
 import io.sentry.SentryLevel
 import io.sentry.SentryOptions
 import io.sentry.Session
@@ -32,7 +33,8 @@ class LifecycleWatcherTest {
   private class Fixture {
     val scopes = mock<IScopes>()
     val dateProvider = mock<ICurrentDateProvider>()
-    val options = SentryOptions()
+    // a real executor so scheduled end-session tasks actually run
+    val options = SentryOptions().apply { setTimerExecutorService(SentryExecutorService(this)) }
     val replayController = mock<ReplayController>()
     val continuousProfiler = mock<IContinuousProfiler>()
 
@@ -115,10 +117,10 @@ class LifecycleWatcherTest {
     watcher.onForeground()
 
     watcher.onBackground()
-    assertNotNull(watcher.timerTask)
+    assertNotNull(watcher.endSessionFuture)
 
     watcher.onForeground()
-    assertNull(watcher.timerTask)
+    assertNull(watcher.endSessionFuture)
 
     verify(fixture.scopes, never()).endSession()
     verify(fixture.replayController, never()).stop()
@@ -186,13 +188,6 @@ class LifecycleWatcherTest {
     verify(fixture.scopes, never()).addBreadcrumb(any<Breadcrumb>())
   }
 
-  @Test
-  fun `timer is created if session tracking is enabled`() {
-    val watcher =
-      fixture.getSUT(enableAutoSessionTracking = true, enableAppLifecycleBreadcrumbs = false)
-    assertNotNull(watcher.timer)
-  }
-
   @Test
   fun `if the scopes has already a fresh session running, don't start new one`() {
     val watcher =

From 4670d89b9bdbc4d8346b20edf9489b4cb97bffcc Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 23 Jul 2026 10:46:54 +0200
Subject: [PATCH 321/391] build(android): Pin AAR minCompileSdk to minSdk
 (#5823)

* build(android): Pin AAR minCompileSdk to minSdk

AGP 9 changed the default so a published library's AAR metadata
minCompileSdk mirrors its compileSdk, which we recently bumped to 37.
That would force every consumer of the Android SDK onto compileSdk 37.

Pin minCompileSdk to our minSdk for all published Android library
modules so consumers stay free to compile against any SDK we support,
preserving the pre-AGP-9 behavior.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md     | 4 ++++
 build.gradle.kts | 7 +++++++
 2 files changed, 11 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e1561ebfa3..f46c77b306c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Fixes
+
+- Pin the published Sentry Android SDK's AAR metadata `minCompileSdk` to our `minSdk` (`21`) instead of AGP 9's new default of the SDK's own `compileSdk` (`37`), so apps that depend on the SDK aren't forced to raise their `compileSdk` ([#5823](https://github.com/getsentry/sentry-java/pull/5823))
+
 ### Performance
 
 - Reduce the number of SDK threads: `LifecycleWatcher` now schedules the session-end task on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5819](https://github.com/getsentry/sentry-java/pull/5819))
diff --git a/build.gradle.kts b/build.gradle.kts
index 764667ecd65..7d8cfcb626e 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -177,6 +177,13 @@ subprojects {
                     sourceCompatibility = JavaVersion.VERSION_1_8
                     targetCompatibility = JavaVersion.VERSION_1_8
                 }
+
+                // AGP 9 defaults the AAR metadata minCompileSdk to the library's compileSdk,
+                // which would force every consumer onto that compile SDK. Pin it to our minSdk
+                // so consumers remain free to compile against any SDK we support, as before.
+                defaultConfig {
+                    aarMetadata { minCompileSdk = libs.versions.minSdk.get().toInt() }
+                }
             }
         }
 

From bbcf99a5d31eadda0ad23b3bef08bfda0db63756 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 23 Jul 2026 16:00:50 +0200
Subject: [PATCH 322/391] fix(replay): Release MediaMuxer when the encoder
 fails to start (#5607)

* fix(replay): Release MediaMuxer when the encoder fails to start

The MediaMuxer is opened eagerly in SimpleVideoEncoder's constructor, but
its release() was only reachable on paths that assume start() succeeded.
Two cases leaked it:

- createVideoOf constructed the encoder and called start() in one
  expression, so when start() threw the encoder was never assigned and
  release() could never run.
- SimpleVideoEncoder.release() released the muxer as the last statement of
  the try block, after draining and stopping the codec. Draining a codec
  that never started throws, skipping the muxer release.

Release the encoder if start() throws, and always release the muxer from a
finally block so it is freed even when draining/stopping the codec fails.
This surfaced as a CloseGuard "resource was acquired but never released"
warning. Complements #5583.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

* fix(replay): Skip MediaMuxer stop when no samples were written

MediaMuxer.stop() throws IllegalStateException when the muxer was started
but no sample was ever written to its track. SimpleMp4FrameMuxer.release()
only guarded against the never-started case, so a started-but-empty muxer
made release() throw.

Because release() runs from SimpleVideoEncoder's finally block, that throw
propagates out to createVideoOf, which treats release() as safe cleanup;
the encoder is left dangling and the orphan video file is never deleted.

Only call stop() when at least one sample was written; muxer.release() on a
started-but-not-stopped muxer is safe.

* Format code

* fix(replay): Guard each native release so cleanup never propagates

The finally block in SimpleVideoEncoder.release() released the codec,
surface, and muxer without guards. release() is treated by callers such as
createVideoOf as safe cleanup, but MediaMuxer.stop() (reached via
frameMuxer.release()) can still throw IllegalStateException on a genuine
file-finalization failure even when samples were written. That would skip
the remaining releases and propagate out of release().

Guard each release independently so failing to free one resource neither
skips the others nor escapes to the caller.

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                  |  1 +
 .../io/sentry/android/replay/ReplayCache.kt   | 11 ++++++++-
 .../replay/video/SimpleMp4FrameMuxer.kt       |  7 +++---
 .../replay/video/SimpleVideoEncoder.kt        | 23 +++++++++++++++----
 .../sentry/android/replay/ReplayCacheTest.kt  | 23 +++++++++++++++++++
 .../replay/util/ReplayShadowMediaCodec.kt     |  4 ++++
 6 files changed, 60 insertions(+), 9 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f46c77b306c..edd2c8d174d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Fixes
 
 - Pin the published Sentry Android SDK's AAR metadata `minCompileSdk` to our `minSdk` (`21`) instead of AGP 9's new default of the SDK's own `compileSdk` (`37`), so apps that depend on the SDK aren't forced to raise their `compileSdk` ([#5823](https://github.com/getsentry/sentry-java/pull/5823))
+- Release `MediaMuxer` when the replay video encoder fails to start to avoid a resource leak ([#5607](https://github.com/getsentry/sentry-java/pull/5607))
 
 ### Performance
 
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
index b54177bca9b..55891fea1a7 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
@@ -162,7 +162,16 @@ public class ReplayCache(private val options: SentryOptions, private val replayI
               bitRate = bitRate,
             ),
           )
-          .also { it.start() }
+          .apply {
+            // the constructor already opened the MediaMuxer, so release it if start() fails,
+            // otherwise the encoder is never assigned and its resources leak (CloseGuard warning)
+            try {
+              start()
+            } catch (t: Throwable) {
+              release()
+              throw t
+            }
+          }
       }
 
     val step = 1000 / frameRate.toLong()
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleMp4FrameMuxer.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleMp4FrameMuxer.kt
index e32af9bb44b..0063cf636e4 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleMp4FrameMuxer.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleMp4FrameMuxer.kt
@@ -67,9 +67,10 @@ internal class SimpleMp4FrameMuxer(path: String, fps: Float) : SimpleFrameMuxer
   }
 
   override fun release() {
-    // stop() throws if the muxer was never started (e.g. no frame was ever muxed), so we guard it
-    // to ensure release() is always reached and the underlying resources are freed
-    if (started) {
+    // stop() throws unless the muxer was started AND at least one sample was written, so we guard
+    // it
+    // to ensure muxer.release() is always reached and the underlying resources are freed
+    if (started && videoFrames > 0) {
       muxer.stop()
     }
     muxer.release()
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
index 04d573d793f..d0cafd9f1a9 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
@@ -287,12 +287,25 @@ internal class SimpleVideoEncoder(
       onClose?.invoke()
       drainCodec(true)
       mediaCodec.stop()
-      mediaCodec.release()
-      surface?.release()
-
-      frameMuxer.release()
-    } catch (e: Throwable) {
+    } catch (e: RuntimeException) {
       options.logger.log(DEBUG, "Failed to properly release video encoder", e)
+    } finally {
+      // always release the native resources, even if draining/stopping the codec above threw (e.g.
+      // when the encoder failed to fully start), otherwise they leak (CloseGuard warning). guard
+      // each
+      // call so failing to release one resource neither skips the others nor propagates to callers,
+      // which treat release() as safe cleanup
+      releaseQuietly("MediaCodec") { mediaCodec.release() }
+      releaseQuietly("Surface") { surface?.release() }
+      releaseQuietly("MediaMuxer") { frameMuxer.release() }
+    }
+  }
+
+  private inline fun releaseQuietly(name: String, block: () -> Unit) {
+    try {
+      block()
+    } catch (e: RuntimeException) {
+      options.logger.log(DEBUG, "Failed to release $name", e)
     }
   }
 }
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt
index 8b64ca5caeb..23e8d60044f 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt
@@ -28,6 +28,7 @@ import java.util.concurrent.atomic.AtomicReference
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 import kotlin.test.assertFalse
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
@@ -36,6 +37,7 @@ import org.junit.rules.TemporaryFolder
 import org.junit.runner.RunWith
 import org.robolectric.annotation.Config
 import org.robolectric.shadows.ShadowBitmapFactory
+import org.robolectric.shadows.ShadowCloseGuard
 
 @RunWith(AndroidJUnit4::class)
 @Config(sdk = [26], shadows = [ReplayShadowMediaCodec::class])
@@ -56,6 +58,7 @@ class ReplayCacheTest {
   @BeforeTest
   fun `set up`() {
     ReplayShadowMediaCodec.framesToEncode = 5
+    ReplayShadowMediaCodec.throwOnStart = false
     ShadowBitmapFactory.setAllowInvalidImageData(true)
   }
 
@@ -93,6 +96,26 @@ class ReplayCacheTest {
     assertNull(video)
   }
 
+  @Test
+  fun `releases the muxer when the encoder fails to start`() {
+    ReplayShadowMediaCodec.throwOnStart = true
+    val replayCache = fixture.getSut(tmpDir)
+
+    val bitmap = Bitmap.createBitmap(1, 1, ARGB_8888)
+    replayCache.addFrame(bitmap, 1)
+
+    ShadowCloseGuard.reset()
+    assertFailsWith<IllegalStateException> {
+      replayCache.createVideoOf(5000L, 0, 0, 100, 200, 1, 20_000)
+    }
+
+    val muxerLeaks =
+      ShadowCloseGuard.getErrors().filter { error ->
+        error.stackTrace.any { it.className.contains("MediaMuxer") }
+      }
+    assertTrue(muxerLeaks.isEmpty(), "MediaMuxer was not released: $muxerLeaks")
+  }
+
   @Test
   fun `deletes frames after creating a video`() {
     ReplayShadowMediaCodec.framesToEncode = 3
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ReplayShadowMediaCodec.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ReplayShadowMediaCodec.kt
index f60c6688386..60ccb157747 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ReplayShadowMediaCodec.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ReplayShadowMediaCodec.kt
@@ -15,12 +15,16 @@ class ReplayShadowMediaCodec : ShadowMediaCodec() {
   companion object {
     var frameRate = 1
     var framesToEncode = 5
+    var throwOnStart = false
   }
 
   private val encoded = AtomicBoolean(false)
 
   @Implementation
   fun start() {
+    if (throwOnStart) {
+      throw IllegalStateException("Simulated codec start failure")
+    }
     super.native_start()
   }
 

From 01572ad9a54c43d7cb53a1a7955a683b38ff521d Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 23 Jul 2026 16:01:34 +0200
Subject: [PATCH 323/391] perf(android): mini optimization: Guard manifest
 metadata debug logs behind isEnabled (#5790)

* perf(android): Guard manifest metadata debug logs behind isEnabled (JAVA-614)

The read helpers in ManifestMetadataReader built the debug message
(key + " read: " + value) unconditionally at the call site, and
DiagnosticLogger only filtered on options.isDebug() afterward. With
debug=false (the default) that discarded ~100 StringBuilder/String
allocations per init.

Guard the six read helpers with logger.isEnabled(DEBUG) so the message
is only constructed when debug logging is actually on. Behavior is
unchanged; this is a pure allocation/GC-pressure reduction on the init
path.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  4 ++++
 .../android/core/ManifestMetadataReader.java  | 24 ++++++++++++++-----
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index edd2c8d174d..35f1f30820b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Improvements
+
+- Skip building Android manifest metadata debug log messages when debug logging is disabled, reducing allocations during SDK init ([#5790](https://github.com/getsentry/sentry-java/pull/5790))
+
 ### Fixes
 
 - Pin the published Sentry Android SDK's AAR metadata `minCompileSdk` to our `minSdk` (`21`) instead of AGP 9's new default of the SDK's own `compileSdk` (`37`), so apps that depend on the SDK aren't forced to raise their `compileSdk` ([#5823](https://github.com/getsentry/sentry-java/pull/5823))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 7a9cd8a4d13..469f15e3f3b 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -779,7 +779,9 @@ private static boolean readBool(
       final @NotNull String key,
       final boolean defaultValue) {
     final boolean value = metadata.getBoolean(key, defaultValue);
-    logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    if (logger.isEnabled(SentryLevel.DEBUG)) {
+      logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    }
     return value;
   }
 
@@ -789,7 +791,9 @@ private static boolean readBool(
       final @NotNull String key,
       final @Nullable String defaultValue) {
     final String value = metadata.getString(key, defaultValue);
-    logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    if (logger.isEnabled(SentryLevel.DEBUG)) {
+      logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    }
     return value;
   }
 
@@ -799,14 +803,18 @@ private static boolean readBool(
       final @NotNull String key,
       final @NotNull String defaultValue) {
     final String value = metadata.getString(key, defaultValue);
-    logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    if (logger.isEnabled(SentryLevel.DEBUG)) {
+      logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    }
     return value;
   }
 
   private static @Nullable List<String> readList(
       final @NotNull Bundle metadata, final @NotNull ILogger logger, final @NotNull String key) {
     final String value = metadata.getString(key);
-    logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    if (logger.isEnabled(SentryLevel.DEBUG)) {
+      logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    }
     if (value != null) {
       return Arrays.asList(value.split(",", -1));
     } else {
@@ -821,7 +829,9 @@ private static double readDouble(
     if (value == -1) {
       value = ((Integer) metadata.getInt(key, -1)).doubleValue();
     }
-    logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    if (logger.isEnabled(SentryLevel.DEBUG)) {
+      logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    }
     return value;
   }
 
@@ -832,7 +842,9 @@ private static long readLong(
       final long defaultValue) {
     // manifest meta-data only reads int if the value is not big enough
     final long value = metadata.getInt(key, (int) defaultValue);
-    logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    if (logger.isEnabled(SentryLevel.DEBUG)) {
+      logger.log(SentryLevel.DEBUG, key + " read: " + value);
+    }
     return value;
   }
 

From 02e6bc88fab20573b7205ba54d08a46a63c9ec43 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 23 Jul 2026 16:02:02 +0200
Subject: [PATCH 324/391] build: Disable Android debug variants outside the
 sample app (#5825)

Unit tests already target the release variant (testBuildType = release)
and CI disabled the debug variant. Disable the debug variant locally too
so local builds match CI and skip building the unused variant. The
sample app keeps both variants for manual runs and profiling.

Update the contributor docs and test skill to reference
testReleaseUnitTest instead of testDebugUnitTest.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .claude/skills/test/SKILL.md                           | 6 +++---
 .cursor/rules/coding.mdc                               | 2 +-
 AGENTS.md                                              | 4 ++--
 buildSrc/src/main/java/Config.kt                       | 4 +++-
 sentry-android-core/build.gradle.kts                   | 6 +++---
 sentry-android-distribution/build.gradle.kts           | 4 ++--
 sentry-android-fragment/build.gradle.kts               | 4 ++--
 sentry-android-navigation/build.gradle.kts             | 4 ++--
 sentry-android-ndk/build.gradle.kts                    | 4 ++--
 sentry-android-replay/build.gradle.kts                 | 4 ++--
 sentry-android-sqlite/build.gradle.kts                 | 4 ++--
 sentry-android-timber/build.gradle.kts                 | 4 ++--
 sentry-compose/build.gradle.kts                        | 4 ++--
 sentry-launchdarkly-android/build.gradle.kts           | 4 ++--
 sentry-samples/sentry-samples-android/build.gradle.kts | 7 +++----
 15 files changed, 33 insertions(+), 32 deletions(-)

diff --git a/.claude/skills/test/SKILL.md b/.claude/skills/test/SKILL.md
index bdef12364f3..7e6ddd37294 100644
--- a/.claude/skills/test/SKILL.md
+++ b/.claude/skills/test/SKILL.md
@@ -40,9 +40,9 @@ Determine the Gradle test task:
 
 | Module Pattern | Test Task |
 |---------------|-----------|
-| `sentry-android-*` | `testDebugUnitTest` |
-| `sentry-compose*` | `testDebugUnitTest` |
-| `*-android` | `testDebugUnitTest` |
+| `sentry-android-*` | `testReleaseUnitTest` |
+| `sentry-compose*` | `testReleaseUnitTest` |
+| `*-android` | `testReleaseUnitTest` |
 | Everything else | `test` |
 
 **Interactive mode:** Before running, read the test class file and use AskUserQuestion to ask:
diff --git a/.cursor/rules/coding.mdc b/.cursor/rules/coding.mdc
index fbcda27b120..70ac39e43a2 100644
--- a/.cursor/rules/coding.mdc
+++ b/.cursor/rules/coding.mdc
@@ -24,7 +24,7 @@ sentry-java is the Java and Android SDK for Sentry. This repository contains the
 ./gradlew check
 
 # Run unit tests for a specific file
-./gradlew ':<module>:testDebugUnitTest' --tests="*<file name>*" --info
+./gradlew ':<module>:testReleaseUnitTest' --tests="*<file name>*" --info
 ```
 
 ## Contributing Guidelines
diff --git a/AGENTS.md b/AGENTS.md
index ec2ef62974c..de4e29376ad 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -44,13 +44,13 @@ The project uses **Gradle** with Kotlin DSL. Key build files:
 ### Testing
 ```bash
 # Run unit tests for a specific file
-./gradlew ':<module>:testDebugUnitTest' --tests="*<file name>*" --info
+./gradlew ':<module>:testReleaseUnitTest' --tests="*<file name>*" --info
 
 # Run system tests (requires Python virtual env)
 make systemTest
 
 # Run specific test suites
-./gradlew :sentry-android-core:testDebugUnitTest
+./gradlew :sentry-android-core:testReleaseUnitTest
 ./gradlew :sentry:test
 ```
 
diff --git a/buildSrc/src/main/java/Config.kt b/buildSrc/src/main/java/Config.kt
index 7575670a38a..09d2869988b 100644
--- a/buildSrc/src/main/java/Config.kt
+++ b/buildSrc/src/main/java/Config.kt
@@ -12,8 +12,10 @@ object Config {
     object Android {
         val abiFilters = listOf("x86", "armeabi-v7a", "x86_64", "arm64-v8a")
 
+        // Debug variants are disabled everywhere. Unit tests run against the release
+        // variant, so building the debug variant would only add overhead.
         fun shouldSkipDebugVariant(name: String?): Boolean {
-            return System.getenv("CI")?.toBoolean() ?: false && name == "debug"
+            return name == "debug"
         }
     }
 
diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index f92876530fd..23248d6dae4 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -34,8 +34,8 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   kotlin { compilerOptions.jvmTarget = JVM_1_8 }
@@ -83,7 +83,7 @@ tasks.withType<JavaCompile>().configureEach {
 // outputs so Gradle's build cache restores them on cache hits (otherwise the CLI upload step
 // finds an empty directory).
 tasks
-  .matching { it.name == "testDebugUnitTest" || it.name == "testReleaseUnitTest" }
+  .matching { it.name == "testReleaseUnitTest" }
   .configureEach { outputs.dir(layout.buildDirectory.dir("test-snapshots")) }
 
 dependencies {
diff --git a/sentry-android-distribution/build.gradle.kts b/sentry-android-distribution/build.gradle.kts
index 363bce003f4..c699c364c3b 100644
--- a/sentry-android-distribution/build.gradle.kts
+++ b/sentry-android-distribution/build.gradle.kts
@@ -13,8 +13,8 @@ android {
   defaultConfig { minSdk = libs.versions.minSdk.get().toInt() }
   buildFeatures { buildConfig = false }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   testOptions {
diff --git a/sentry-android-fragment/build.gradle.kts b/sentry-android-fragment/build.gradle.kts
index 197c0b05d6a..3ef1c1934f8 100644
--- a/sentry-android-fragment/build.gradle.kts
+++ b/sentry-android-fragment/build.gradle.kts
@@ -25,8 +25,8 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   kotlin {
diff --git a/sentry-android-navigation/build.gradle.kts b/sentry-android-navigation/build.gradle.kts
index 5ac9842548f..6c1aa62a57d 100644
--- a/sentry-android-navigation/build.gradle.kts
+++ b/sentry-android-navigation/build.gradle.kts
@@ -25,8 +25,8 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   kotlin {
diff --git a/sentry-android-ndk/build.gradle.kts b/sentry-android-ndk/build.gradle.kts
index ba651da56ac..6867d964124 100644
--- a/sentry-android-ndk/build.gradle.kts
+++ b/sentry-android-ndk/build.gradle.kts
@@ -26,8 +26,8 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8 }
diff --git a/sentry-android-replay/build.gradle.kts b/sentry-android-replay/build.gradle.kts
index 02f2dab3d4d..45838cb1e1b 100644
--- a/sentry-android-replay/build.gradle.kts
+++ b/sentry-android-replay/build.gradle.kts
@@ -34,8 +34,8 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   kotlin {
diff --git a/sentry-android-sqlite/build.gradle.kts b/sentry-android-sqlite/build.gradle.kts
index e1e3bc68765..9cf09fd76fd 100644
--- a/sentry-android-sqlite/build.gradle.kts
+++ b/sentry-android-sqlite/build.gradle.kts
@@ -25,8 +25,8 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   kotlin {
diff --git a/sentry-android-timber/build.gradle.kts b/sentry-android-timber/build.gradle.kts
index e55b8b0e3c5..3c8ac1ea1e4 100644
--- a/sentry-android-timber/build.gradle.kts
+++ b/sentry-android-timber/build.gradle.kts
@@ -32,8 +32,8 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   kotlin {
diff --git a/sentry-compose/build.gradle.kts b/sentry-compose/build.gradle.kts
index 388bfe832bb..4ebd9349662 100644
--- a/sentry-compose/build.gradle.kts
+++ b/sentry-compose/build.gradle.kts
@@ -92,8 +92,8 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   testOptions {
diff --git a/sentry-launchdarkly-android/build.gradle.kts b/sentry-launchdarkly-android/build.gradle.kts
index 32b3641203f..f201c57b97d 100644
--- a/sentry-launchdarkly-android/build.gradle.kts
+++ b/sentry-launchdarkly-android/build.gradle.kts
@@ -27,8 +27,8 @@ android {
     getByName("release") { consumerProguardFiles("proguard-rules.pro") }
   }
 
-  // AGP 9 only generates unit tests for the testBuildType. CI disables the debug
-  // variant, so unit tests must target release to run at all.
+  // AGP 9 only generates unit tests for the testBuildType. The debug variant is
+  // disabled, so unit tests must target release to run at all.
   testBuildType = "release"
 
   kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_1_8 }
diff --git a/sentry-samples/sentry-samples-android/build.gradle.kts b/sentry-samples/sentry-samples-android/build.gradle.kts
index f994081450d..31009f6dbb9 100644
--- a/sentry-samples/sentry-samples-android/build.gradle.kts
+++ b/sentry-samples/sentry-samples-android/build.gradle.kts
@@ -114,6 +114,9 @@ android {
       // Suffix the id so debug and release builds can be installed side by side.
       applicationIdSuffix = ".debug"
       addManifestPlaceholders(mapOf("sentryDebug" to true, "sentryEnvironment" to "debug"))
+      // The SDK modules only publish a release variant, so fall back to it for the
+      // debug build of the sample.
+      matchingFallbacks += "release"
     }
     getByName("release") {
       isMinifyEnabled = true
@@ -133,10 +136,6 @@ android {
 
   kotlin { compilerOptions.jvmTarget = org.jetbrains.kotlin.gradle.dsl.JvmTarget.JVM_11 }
 
-  androidComponents.beforeVariants {
-    it.enable = !Config.Android.shouldSkipDebugVariant(it.buildType)
-  }
-
   androidComponents.onVariants { variant ->
     variant.buildConfigFields?.put(
       "USE_SAGP",

From cc65dda49f6371b5f1c3ddd455a5de84f2f4a5ab Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Fri, 24 Jul 2026 09:45:53 +0200
Subject: [PATCH 325/391] Fix Changelog (#5829)

---
 CHANGELOG.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 35f1f30820b..cfd2e8d0f78 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,13 +8,18 @@
 
 ### Fixes
 
-- Pin the published Sentry Android SDK's AAR metadata `minCompileSdk` to our `minSdk` (`21`) instead of AGP 9's new default of the SDK's own `compileSdk` (`37`), so apps that depend on the SDK aren't forced to raise their `compileSdk` ([#5823](https://github.com/getsentry/sentry-java/pull/5823))
 - Release `MediaMuxer` when the replay video encoder fails to start to avoid a resource leak ([#5607](https://github.com/getsentry/sentry-java/pull/5607))
 
 ### Performance
 
 - Reduce the number of SDK threads: `LifecycleWatcher` now schedules the session-end task on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5819](https://github.com/getsentry/sentry-java/pull/5819))
 
+## 8.50.1
+
+### Fixes
+
+- Pin the published Sentry Android SDK's AAR metadata `minCompileSdk` to our `minSdk` (`21`) instead of AGP 9's new default of the SDK's own `compileSdk` (`37`), so apps that depend on the SDK aren't forced to raise their `compileSdk` ([#5823](https://github.com/getsentry/sentry-java/pull/5823))
+
 ## 8.50.0
 
 ### Android 17 support

From 6335e357adb957c9397e82c74c3ab20f5d9392f0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 24 Jul 2026 07:51:36 +0000
Subject: [PATCH 326/391] chore(deps): bump the github-actions group across 1
 directory with 2 updates (#5809)

Bumps the github-actions group with 2 updates in the / directory: [github/codeql-action/init](https://github.com/github/codeql-action) and [github/codeql-action/analyze](https://github.com/github/codeql-action).


Updates `github/codeql-action/init` from 4.37.1 to 4.37.3
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/7188fc363630916deb702c7fdcf4e481b751f97a...e4fba868fa4b1b91e1fdab776edc8cfbe6e9fb81)

Updates `github/codeql-action/analyze` from 4.37.1 to 4.37.3
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/7188fc363630916deb702c7fdcf4e481b751f97a...e4fba868fa4b1b91e1fdab776edc8cfbe6e9fb81)

---
updated-dependencies:
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.37.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/init
  dependency-version: 4.37.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql-analysis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 919d09659b9..33566af8602 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@7188fc363630916deb702c7fdcf4e481b751f97a # pin@v2
+        uses: github/codeql-action/init@e4fba868fa4b1b91e1fdab776edc8cfbe6e9fb81 # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@7188fc363630916deb702c7fdcf4e481b751f97a # pin@v2
+        uses: github/codeql-action/analyze@e4fba868fa4b1b91e1fdab776edc8cfbe6e9fb81 # pin@v2

From 7414e9b7c87593480d6b235d7bf14393bcf91b8a Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Fri, 24 Jul 2026 17:36:53 +0200
Subject: [PATCH 327/391] fix(replay): Prevent concurrent PixelCopy frame
 access (#5808)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(replay): Prevent concurrent PixelCopy frame access

Keep PixelCopy, masking, compositing, and cleanup from accessing the shared bitmap concurrently.

Fixes GH-5340

Co-Authored-By: Codex <noreply@openai.com>

* changelog

* fix(android-replay): Preserve pending PixelCopy capture

Re-arm the recorder's content-change gate when a capture is skipped because another frame is still in flight. This ensures the latest UI state is retried on the next capture interval.

Refs GH-5340
Co-Authored-By: OpenAI Codex <noreply@openai.com>

* fix(replay): Release PixelCopy frame gate and cleanup on failure paths

Two bugbot findings on #5808:

- Frame gate stuck on callback errors: viewhierarchy traversal or
  captureSurfaceViews throwing between the PixelCopy success check and
  the executor submit left frameInFlight = true forever, silently
  wedging all future captures. Wrap the post-success block in a
  try/finally that releases the gate unless work was successfully
  handed off.
- Cleanup lost after executor shutdown: close() typically runs after
  ReplayIntegration has shut down the replay executor, so submit()
  returns null and the bitmap + maskRenderer were never released. Fall
  back to running cleanup inline in that case.

* chore(replay): Drop redundant handedOff flag in capture callback

The mask branch already knows via 'submitted == null' whether the executor
took ownership; the surface-view branch always hands off. Flatten to
explicit finishFrame() calls on the two failure paths (mask null-submit,
outer catch) instead of tracking handoff state across a try/finally.

* fix(replay): Distinguish inline execution from executor rejection

ReplayExecutorService.submit previously returned null both when the caller
was on the worker thread (task ran inline) and when the executor rejected
the submission (task did NOT run). Callers had no way to tell them apart.

Return a CompletedFuture sentinel for inline execution; null now means
only rejection. Also narrow PixelCopyStrategy's frame-processing catch
from Throwable to RuntimeException so OOM/LinkageError still propagate.

* chore(replay): Drop redundant cleanupScheduled guard

Cleanup body is already idempotent (screenshot.isRecycled check,
MaskRenderer.close guards on isInitialized + isRecycled). A stray extra
scheduleCleanup would just submit a no-op — not worth the AtomicBoolean.

* test(replay): Fix recursive close and assert masking is skipped on close race

The mock executor closed the strategy on every submit(); since close()
itself submits the cleanup task, this recursed
close() -> scheduleCleanup() -> submit() until the stack overflowed.
Close only when the mask task is submitted.

The prior "does not crash" assertion was also vacuous under the
frameInFlight gate (passed even with the isClosed guard removed). Assert
instead that no screenshot is emitted once close() races masking, which
fails if the guard in applyMaskingAndNotify is removed.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(replay): Guard finishFrame cleanup with CAS to avoid recycling a bitmap a new capture is using

finishFrame cleared frameInFlight before checking isClosed, so a new capture could
take the gate and start PixelCopy into the shared screenshot while the old
finishFrame went on to scheduleCleanup after close() flipped isClosed — recycling
the bitmap mid-write. Re-take the gate with compareAndSet before cleaning up so the
losing frame backs off.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(replay): Make close's idle cleanup claim the gate atomically

close() checked !frameInFlight.get() non-atomically before scheduleCleanup, so a
capture racing in after the check could take the gate, see isClosed, and have its
finishFrame schedule a second cleanup. Extract the shared "claim the gate, then the
winner cleans up once" invariant into cleanUpIfIdle() so close() and finishFrame()
use the same CAS.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* test(replay): Return CompletedFuture from inlineExecutor to match ReplayExecutorService

inlineExecutor() returned null from submit, which under the executor's contract means
"rejected" — making capture()'s null-fallback finishFrame run on top of the mask
task's own finally, a double-release production never hits on the inline path. Return
CompletedFuture so the fixture matches the real inline semantics.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(replay): Hold frame gate across emitLastScreenshot to prevent concurrent bitmap access

emitLastScreenshot runs on the main thread, so the downstream consumer queues
its bitmap read (JPEG compress) to the executor asynchronously. Without the
gate, the next capture tick's PixelCopy.request writes into the shared
screenshot while the queued read is still in flight. Submit the consumer call
to the executor so it runs inline on the worker thread while the gate is held,
same pattern as the masked capture path.

Also fixes the close-race test mock to return CompletedFuture instead of null,
matching the executor contract (same fix as inlineExecutor in cd3a7c0).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Codex <noreply@openai.com>
Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   1 +
 .../replay/screenshot/PixelCopyStrategy.kt    | 208 ++++++++++----
 .../replay/util/ReplayExecutorService.kt      |  27 +-
 .../screenshot/PixelCopyStrategyTest.kt       | 266 +++++++++++++++++-
 4 files changed, 434 insertions(+), 68 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index cfd2e8d0f78..b8fc67b6b53 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
 
 ### Fixes
 
+- Prevent concurrent PixelCopy access during Session Replay masking and bitmap cleanup ([#5808](https://github.com/getsentry/sentry-java/pull/5808))
 - Release `MediaMuxer` when the replay video encoder fails to start to avoid a resource leak ([#5607](https://github.com/getsentry/sentry-java/pull/5607))
 
 ### Performance
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
index 4b9618df6ec..14871b45d6d 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
@@ -59,6 +59,7 @@ internal class PixelCopyStrategy(
   private val contentChanged = AtomicBoolean(false)
   private val unstableCaptures = AtomicInteger(0)
   private val isClosed = AtomicBoolean(false)
+  private val frameInFlight = AtomicBoolean(false)
   private val dstOverPaint by
     lazy(NONE) { Paint().apply { xfermode = PorterDuffXfermode(PorterDuff.Mode.DST_OVER) } }
   private val screenshotCanvas by lazy(NONE) { Canvas(screenshot) }
@@ -77,8 +78,15 @@ internal class PixelCopyStrategy(
       return
     }
 
+    if (!frameInFlight.compareAndSet(false, true)) {
+      options.logger.log(DEBUG, "PixelCopyStrategy capture is already in flight, skipping")
+      markContentChanged()
+      return
+    }
+
     if (isClosed.get()) {
       options.logger.log(DEBUG, "PixelCopyStrategy is closed, not capturing screenshot")
+      finishFrame()
       return
     }
 
@@ -90,6 +98,7 @@ internal class PixelCopyStrategy(
         { copyResult: Int ->
           if (isClosed.get()) {
             options.logger.log(DEBUG, "PixelCopyStrategy is closed, ignoring capture result")
+            finishFrame()
             return@request
           }
 
@@ -97,44 +106,64 @@ internal class PixelCopyStrategy(
             options.logger.log(INFO, "Failed to capture replay recording: %d", copyResult)
             unstableCaptures.set(0)
             lastCaptureSuccessful.set(false)
+            finishFrame()
             return@request
           }
 
           val changedDuringCapture = contentChanged.get()
           if (changedDuringCapture && shouldSkipUnstableCapture()) {
+            finishFrame()
             return@request
           }
 
-          // TODO: disableAllMasking here and dont traverse?
-          val viewHierarchy = ViewHierarchyNode.fromView(root, null, 0, options.sessionReplay)
-          val surfaceViewNodes =
-            if (options.sessionReplay.isCaptureSurfaceViews) {
-              mutableListOf<ViewHierarchyNode.SurfaceViewHierarchyNode>()
-            } else {
-              null
-            }
-          root.traverse(viewHierarchy, options.sessionReplay, options.logger, surfaceViewNodes)
-
-          if (surfaceViewNodes.isNullOrEmpty()) {
-            executor.submit(
-              ReplayRunnable("screenshot_recorder.mask") {
-                applyMaskingAndNotify(
-                  root,
-                  viewHierarchy,
-                  resetUnstableCaptures = !changedDuringCapture,
+          // Release the frame gate if anything below throws before we hand work off to the
+          // executor — otherwise a single failure wedges captures forever.
+          try {
+            // TODO: disableAllMasking here and dont traverse?
+            val viewHierarchy = ViewHierarchyNode.fromView(root, null, 0, options.sessionReplay)
+            val surfaceViewNodes =
+              if (options.sessionReplay.isCaptureSurfaceViews) {
+                mutableListOf<ViewHierarchyNode.SurfaceViewHierarchyNode>()
+              } else {
+                null
+              }
+            root.traverse(viewHierarchy, options.sessionReplay, options.logger, surfaceViewNodes)
+
+            if (surfaceViewNodes.isNullOrEmpty()) {
+              val submitted =
+                executor.submit(
+                  ReplayRunnable("screenshot_recorder.mask") {
+                    try {
+                      applyMaskingAndNotify(
+                        root,
+                        viewHierarchy,
+                        resetUnstableCaptures = !changedDuringCapture,
+                      )
+                    } finally {
+                      finishFrame()
+                    }
+                  }
                 )
+              if (submitted == null) {
+                finishFrame()
               }
-            )
-          } else {
-            // Re-arm the recorder's contentChanged gate; SurfaceView redraws don't trigger
-            // ViewTreeObserver.OnDrawListener, so we'd otherwise emit the same frame forever.
-            markContentChanged()
-            captureSurfaceViews(
-              root,
-              surfaceViewNodes,
-              viewHierarchy,
-              resetUnstableCaptures = !changedDuringCapture,
-            )
+            } else {
+              // Re-arm the recorder's contentChanged gate; SurfaceView redraws don't trigger
+              // ViewTreeObserver.OnDrawListener, so we'd otherwise emit the same frame forever.
+              markContentChanged()
+              captureSurfaceViews(
+                root,
+                surfaceViewNodes,
+                viewHierarchy,
+                resetUnstableCaptures = !changedDuringCapture,
+              )
+            }
+          } catch (e: RuntimeException) {
+            // OEM View subclasses have been observed throwing during hierarchy traversal
+            // (e.g. Redmi's TextView NPE). Release the frame gate so a single bad frame
+            // doesn't wedge the recorder. Errors (OOM, LinkageError) intentionally propagate.
+            options.logger.log(WARNING, "Failed to process replay frame", e)
+            finishFrame()
           }
         },
         mainLooperHandler.handler,
@@ -143,6 +172,7 @@ internal class PixelCopyStrategy(
       options.logger.log(WARNING, "Failed to capture replay recording", e)
       unstableCaptures.set(0)
       lastCaptureSuccessful.set(false)
+      finishFrame()
     }
   }
 
@@ -272,37 +302,46 @@ internal class PixelCopyStrategy(
     windowY: Int,
     resetUnstableCaptures: Boolean,
   ) {
-    executor.submit(
-      ReplayRunnable("screenshot_recorder.composite") {
-        if (isClosed.get() || screenshot.isRecycled) {
-          options.logger.log(DEBUG, "PixelCopyStrategy is closed, skipping compositing")
-          recycleCaptures(captures)
-          return@ReplayRunnable
-        }
+    val submitted =
+      executor.submit(
+        ReplayRunnable("screenshot_recorder.composite") {
+          try {
+            if (isClosed.get() || screenshot.isRecycled) {
+              options.logger.log(DEBUG, "PixelCopyStrategy is closed, skipping compositing")
+              recycleCaptures(captures)
+              return@ReplayRunnable
+            }
 
-        for (capture in captures) {
-          if (capture == null) continue
-          if (capture.bitmap.isRecycled) continue
-
-          compositeSurfaceViewInto(
-            screenshotCanvas,
-            dstOverPaint,
-            tmpSrcRect,
-            tmpDstRect,
-            capture.bitmap,
-            capture.x,
-            capture.y,
-            windowX,
-            windowY,
-            config.scaleFactorX,
-            config.scaleFactorY,
-          )
-          capture.bitmap.recycle()
-        }
+            for (capture in captures) {
+              if (capture == null) continue
+              if (capture.bitmap.isRecycled) continue
+
+              compositeSurfaceViewInto(
+                screenshotCanvas,
+                dstOverPaint,
+                tmpSrcRect,
+                tmpDstRect,
+                capture.bitmap,
+                capture.x,
+                capture.y,
+                windowX,
+                windowY,
+                config.scaleFactorX,
+                config.scaleFactorY,
+              )
+              capture.bitmap.recycle()
+            }
 
-        applyMaskingAndNotify(root, viewHierarchy, resetUnstableCaptures)
-      }
-    )
+            applyMaskingAndNotify(root, viewHierarchy, resetUnstableCaptures)
+          } finally {
+            finishFrame()
+          }
+        }
+      )
+    if (submitted == null) {
+      recycleCaptures(captures)
+      finishFrame()
+    }
   }
 
   private fun recycleCaptures(captures: Array<SurfaceViewCapture?>) {
@@ -322,15 +361,57 @@ internal class PixelCopyStrategy(
   }
 
   override fun emitLastScreenshot() {
-    if (lastCaptureSuccessful() && !screenshot.isRecycled) {
-      screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
+    if (!frameInFlight.compareAndSet(false, true)) {
+      return
+    }
+    if (!lastCaptureSuccessful() || screenshot.isRecycled) {
+      finishFrame()
+      return
+    }
+    // Submit to the executor so the downstream consumer's bitmap read (JPEG compress) runs inline
+    // on the worker thread while the gate is held, same as the masked capture path.
+    val submitted =
+      executor.submit(
+        ReplayRunnable("PixelCopyStrategy.emit") {
+          try {
+            screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
+          } finally {
+            finishFrame()
+          }
+        }
+      )
+    if (submitted == null) {
+      finishFrame()
     }
   }
 
   override fun close() {
     isClosed.set(true)
     unstableCaptures.set(0)
-    executor.submit(
+    cleanUpIfIdle()
+  }
+
+  private fun finishFrame() {
+    frameInFlight.set(false)
+    if (isClosed.get()) {
+      cleanUpIfIdle()
+    }
+  }
+
+  /**
+   * Schedules cleanup only for the caller that owns the gate. Whoever wins [frameInFlight]'s CAS
+   * (close when no frame is running, or the finishFrame of the last in-flight frame after close)
+   * runs cleanup exactly once; a racing capture that took the gate loses the CAS and backs off, so
+   * we never recycle the shared screenshot while that capture is still using it.
+   */
+  private fun cleanUpIfIdle() {
+    if (frameInFlight.compareAndSet(false, true)) {
+      scheduleCleanup()
+    }
+  }
+
+  private fun scheduleCleanup() {
+    val cleanup =
       ReplayRunnable(
         "PixelCopyStrategy.close",
         {
@@ -344,7 +425,12 @@ internal class PixelCopyStrategy(
           maskRenderer.close()
         },
       )
-    )
+    // ReplayExecutorService.submit returns null only on genuine rejection (post-shutdown);
+    // inline execution on the worker thread returns a completed future. Fall back to running
+    // cleanup here so the bitmap + mask renderer are freed even when the executor is dead.
+    if (executor.submit(cleanup) == null) {
+      cleanup.run()
+    }
   }
 }
 
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/ReplayExecutorService.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/ReplayExecutorService.kt
index 9e9491f516f..5ba334f8029 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/util/ReplayExecutorService.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/util/ReplayExecutorService.kt
@@ -4,6 +4,7 @@ import io.sentry.SentryLevel.ERROR
 import io.sentry.SentryOptions
 import java.util.concurrent.Future
 import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeUnit.MILLISECONDS
 
 /**
@@ -14,11 +15,20 @@ internal class ReplayExecutorService(
   private val delegate: ScheduledExecutorService,
   private val options: SentryOptions,
 ) : ScheduledExecutorService by delegate {
+  /**
+   * Submits [task] for execution and returns a [Future] describing what happened. The return value
+   * has three distinct outcomes callers can rely on:
+   * - [CompletedFuture] — the caller is already on the replay worker thread, so the task was run
+   *   inline before this method returned. Skips the queue.
+   * - A regular [Future] from the underlying [ScheduledExecutorService] — the task was queued and
+   *   will run asynchronously.
+   * - `null` — the underlying executor rejected the submission (typically because it has been shut
+   *   down). The task did NOT run; callers that need cleanup must handle it themselves.
+   */
   override fun submit(task: Runnable): Future<*>? {
     if (Thread.currentThread().name.startsWith("SentryReplayIntegration")) {
-      // we're already on the worker thread, no need to submit
       task.run()
-      return null
+      return CompletedFuture
     }
     return try {
       delegate.submit {
@@ -68,3 +78,16 @@ internal class ReplayExecutorService(
 }
 
 internal class ReplayRunnable(val taskName: String, delegate: Runnable) : Runnable by delegate
+
+/** A Future that represents an already-completed inline execution — never used as null. */
+internal object CompletedFuture : Future<Unit> {
+  override fun cancel(mayInterruptIfRunning: Boolean): Boolean = false
+
+  override fun isCancelled(): Boolean = false
+
+  override fun isDone(): Boolean = true
+
+  override fun get() {}
+
+  override fun get(timeout: Long, unit: TimeUnit) {}
+}
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
index 779cf7d4311..0098ab24fc6 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
@@ -25,8 +25,11 @@ import io.sentry.SentryOptions
 import io.sentry.android.replay.ExecutorProvider
 import io.sentry.android.replay.ScreenshotRecorderCallback
 import io.sentry.android.replay.ScreenshotRecorderConfig
+import io.sentry.android.replay.util.CompletedFuture
 import io.sentry.android.replay.util.DebugOverlayDrawable
 import io.sentry.android.replay.util.MainLooperHandler
+import io.sentry.android.replay.util.ReplayRunnable
+import java.util.concurrent.Future
 import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicReference
@@ -85,7 +88,10 @@ class PixelCopyStrategyTest {
       return mock {
         doAnswer {
             (it.arguments[0] as Runnable).run()
-            null // submit(Runnable) returns Future<?>; returning Unit breaks the cast
+            // Mirror ReplayExecutorService's inline contract: a completed future, not null. Null
+            // means "rejected" and would make capture() run its null-fallback finishFrame on top of
+            // the task's own, a double-release production never does on the inline path.
+            CompletedFuture
           }
           .whenever(mock)
           .submit(any<Runnable>())
@@ -112,25 +118,30 @@ class PixelCopyStrategyTest {
   }
 
   @Test
-  fun `when close is called while executor task is running, does not crash with recycled bitmap`() {
+  fun `when close races the mask task, masking is skipped and no screenshot is emitted`() {
     val activity = buildActivity(SimpleActivity::class.java).setup()
     shadowOf(Looper.getMainLooper()).idle()
 
     var strategy: PixelCopyStrategy? = null
 
     val failure = AtomicReference<Throwable>()
-    // Custom executor that closes the strategy before executing tasks
+    // Custom executor that closes the strategy right before running the mask task, to simulate
+    // close() racing an in-flight mask task. We key off the mask task specifically (not "the first
+    // submit") because close() itself submits the cleanup task — closing again when that runs would
+    // recurse via close() -> scheduleCleanup() -> submit(), a loop no real code path can produce.
     val executorThatClosesFirst = mock<ScheduledExecutorService>()
     whenever(executorThatClosesFirst.submit(any<Runnable>())).doAnswer {
       val task = it.getArgument<Runnable>(0)
-      strategy?.close()
+      if ((task as? ReplayRunnable)?.taskName == "screenshot_recorder.mask") {
+        strategy?.close()
+      }
       try {
         task.run()
       } catch (e: Throwable) {
         // PixelCopyStrategy swallows the exception, so we have to capture it here and rethrow later
         failure.set(e)
       }
-      null
+      CompletedFuture
     }
 
     strategy = fixture.getSut(executor = executorThatClosesFirst)
@@ -138,6 +149,251 @@ class PixelCopyStrategyTest {
     shadowOf(Looper.getMainLooper()).idle()
 
     if (failure.get() != null) throw failure.get()
+    // close() landed before masking ran, so applyMaskingAndNotify must bail out early and never
+    // hand a screenshot to the callback after the strategy is closed.
+    verify(fixture.callback, never()).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `capture drops frame while PixelCopy is in flight`() {
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+
+    strategy.capture(root)
+    strategy.capture(root)
+
+    assertTrue(fixture.contentChangedMarked.get())
+
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    verify(fixture.callback).onScreenshotRecorded(any<Bitmap>())
+
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    verify(fixture.callback, times(2)).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `capture drops frame while masking is in flight`() {
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+    val tasks = mutableListOf<Runnable>()
+    val executor = mock<ScheduledExecutorService>()
+    whenever(executor.submit(any<Runnable>())).doAnswer {
+      tasks += it.getArgument<Runnable>(0)
+      mock<Future<*>>()
+    }
+    val strategy = fixture.getSut(executor)
+
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertEquals(1, tasks.size)
+    tasks.removeAt(0).run()
+
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertEquals(1, tasks.size)
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `emitLastScreenshot skips while frame is in flight`() {
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+    val strategy = fixture.getSut(executor = fixture.inlineExecutor())
+    captureStableFrame(strategy, root)
+
+    strategy.capture(root)
+    strategy.emitLastScreenshot()
+
+    verify(fixture.callback).onScreenshotRecorded(any<Bitmap>())
+
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+    verify(fixture.callback, times(2)).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `emitLastScreenshot holds the frame gate until the emit task drains`() {
+    // emit submits the consumer call to the executor so the bitmap read (JPEG compress) runs
+    // inline on the worker thread while the gate is held — same pattern as the masked capture path.
+    // Invariant: while the emit task is still queued (gate held), a racing capture is dropped.
+    // Without the gate (old `if (!frameInFlight.get())`) that capture proceeds -> extra frame.
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+    val tasks = mutableListOf<Runnable>()
+    val executor = mock<ScheduledExecutorService>()
+    whenever(executor.submit(any<Runnable>())).doAnswer {
+      tasks.add(it.arguments[0] as Runnable)
+      mock<Future<*>>()
+    }
+    val strategy = fixture.getSut(executor)
+
+    // Set up a successful last capture: capture -> queued mask task -> drain releases the gate.
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+    tasks.removeAll {
+      it.run()
+      true
+    }
+    verify(fixture.callback, times(1)).onScreenshotRecorded(any<Bitmap>())
+
+    // Emit takes the gate and queues the consumer task (still pending).
+    strategy.emitLastScreenshot()
+    // Callback hasn't fired yet — the task is queued, not drained.
+    verify(fixture.callback, times(1)).onScreenshotRecorded(any<Bitmap>())
+
+    // A capture racing in before the emit task drains must be dropped (gate held).
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+    verify(fixture.callback, times(1)).onScreenshotRecorded(any<Bitmap>())
+
+    // Drain the emit task -> callback fires, gate released -> captures resume.
+    tasks.removeAll {
+      it.run()
+      true
+    }
+    verify(fixture.callback, times(2)).onScreenshotRecorded(any<Bitmap>())
+    captureStableFrame(strategy, root)
+    tasks.removeAll {
+      it.run()
+      true
+    }
+    verify(fixture.callback, times(3)).onScreenshotRecorded(any<Bitmap>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `close defers cleanup until PixelCopy completes`() {
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+    val executor = mock<ScheduledExecutorService>()
+    val strategy = fixture.getSut(executor)
+
+    strategy.capture(root)
+    strategy.close()
+
+    verify(executor, never()).submit(any<Runnable>())
+
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    verify(executor).submit(any<Runnable>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `close-triggered cleanup keeps the frame gate so a racing capture cannot double-clean up`() {
+    // Guards the CAS handoff in finishFrame(). The real race is a 3-thread interleave (a new
+    // capture takes the gate the instant finishFrame releases it, then the old finishFrame recycles
+    // the bitmap the new capture is writing) and isn't deterministically reproducible single-
+    // threaded. This exercises its observable invariant instead: when finishFrame cleans up on
+    // close, it must re-take the gate (frameInFlight stays held), so any later capture is dropped
+    // rather than sneaking through to schedule a *second* cleanup on the shared screenshot.
+    // Without the CAS (plain frameInFlight.set(false)) the gate is left free and the follow-up
+    // capture reaches the isClosed guard and schedules cleanup again -> 2 submits.
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+    val executor = mock<ScheduledExecutorService>()
+    whenever(executor.submit(any<Runnable>())).thenReturn(mock<Future<*>>())
+    val strategy = fixture.getSut(executor)
+
+    strategy.capture(root)
+    strategy.close() // in-flight -> cleanup deferred, no submit yet
+
+    // PixelCopy completes; the callback sees isClosed and runs finishFrame -> the one cleanup.
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    // A capture racing in after close must be dropped (gate still held), not schedule cleanup
+    // again.
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    verify(executor, times(1)).submit(any<Runnable>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `idle close claims the gate so a racing capture cannot schedule a second cleanup`() {
+    // Mirror of the finishFrame guard, but for close()'s idle path (no frame in flight). close()
+    // must atomically claim the gate before scheduling cleanup; otherwise a capture racing in right
+    // after the check can take the gate, see isClosed, run finishFrame and schedule cleanup a
+    // second
+    // time. Both cleanups are idempotent, but a single submit is the invariant we keep uniform.
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+    val executor = mock<ScheduledExecutorService>()
+    whenever(executor.submit(any<Runnable>())).thenReturn(mock<Future<*>>())
+    val strategy = fixture.getSut(executor)
+
+    strategy.close() // idle -> claims gate, schedules the one cleanup
+    // A capture landing after close must be dropped (gate held), not schedule cleanup again.
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    verify(executor, times(1)).submit(any<Runnable>())
+  }
+
+  @Test
+  @Config(shadows = [DeferredWindowPixelCopyShadow::class])
+  fun `frame gate is released when masking submit is rejected`() {
+    val activity = buildActivity(SimpleActivity::class.java).setup()
+    shadowOf(Looper.getMainLooper()).idle()
+    val root = activity.get().findViewById<View>(android.R.id.content)
+    // Simulate an already-shutdown executor: submit returns null.
+    val executor = mock<ScheduledExecutorService>()
+    whenever(executor.submit(any<Runnable>())).thenReturn(null)
+    val strategy = fixture.getSut(executor)
+
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    // Gate must have been released; a follow-up capture should proceed rather than being dropped.
+    strategy.capture(root)
+    DeferredWindowPixelCopyShadow.flush()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    verify(executor, times(2)).submit(any<Runnable>())
+  }
+
+  @Test
+  fun `close cleans up inline when executor is already shut down`() {
+    // submit returns null → previously the bitmap + maskRenderer would leak.
+    val executor = mock<ScheduledExecutorService>()
+    whenever(executor.submit(any<Runnable>())).thenReturn(null)
+    val strategy = fixture.getSut(executor)
+
+    strategy.close()
+
+    // No crash and the submit was attempted exactly once (cleanup ran inline as fallback).
+    verify(executor).submit(any<Runnable>())
   }
 
   @Test

From a6214895f88fbf112bb7fd69d67b27cfebc92696 Mon Sep 17 00:00:00 2001
From: "sentry-junior[bot]"
 <264270552+sentry-junior[bot]@users.noreply.github.com>
Date: Mon, 27 Jul 2026 11:45:19 +0200
Subject: [PATCH 328/391] ci(warden): Drop anthropic model pin so CI inherits
 org default (#5839)

getsentry Warden CI only provides WARDEN_OPENROUTER_API_KEY. Pinning
anthropic/claude-sonnet-4-6 in repo warden.toml fails auth. Unset the
model so runs inherit getsentry/.github openrouter/moonshotai/kimi-k3.

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: Roman Zavarnitsyn <roman.zavarnitsyn@sentry.io>
---
 warden.toml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/warden.toml b/warden.toml
index 3ce15f9a11f..f13067372ce 100644
--- a/warden.toml
+++ b/warden.toml
@@ -1,7 +1,10 @@
 version = 1
 
 [defaults]
-model = "anthropic/claude-sonnet-4-6"
+# Model intentionally unset so CI inherits the org base default from
+# getsentry/.github/warden.toml (currently openrouter/moonshotai/kimi-k3).
+# getsentry Warden CI only provides WARDEN_OPENROUTER_API_KEY; pinning an
+# anthropic/* model fails auth.
 
 # Warden's schema does not support per-skill verification config; this is the only
 # placement available. Disabled for attribution policy checks: a second verifier

From cb927487b3068f1fd6f99b7ceb8a2d47feea1120 Mon Sep 17 00:00:00 2001
From: "sentry-junior[bot]"
 <264270552+sentry-junior[bot]@users.noreply.github.com>
Date: Mon, 27 Jul 2026 13:02:00 +0200
Subject: [PATCH 329/391] ci(android): Increase API 37 emulator memory (#5840)

* ci(android): Increase API 37 emulator memory

Co-Authored-By: Roman Zavarnitsyn <roman.zavarnitsyn@sentry.io>

* ci: Include emulator memory in AVD cache key
Co-Authored-By: Roman Zavarnitsyn <roman.zavarnitsyn@sentry.io>

---------

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: Roman Zavarnitsyn <roman.zavarnitsyn@sentry.io>
---
 .../workflows/integration-tests-ui-critical.yml   | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 1d054079f1d..2ee76141eb2 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -63,22 +63,27 @@ jobs:
             target: google_apis
             channel: canary # Necessary for ATDs
             arch: x86_64
+            memory: 4096
           - api-level: 33 # Android 13
             target: google_apis
             channel: canary # Necessary for ATDs
             arch: x86_64
+            memory: 4096
           - api-level: 35 # Android 15
             target: google_apis
             channel: canary # Necessary for ATDs
             arch: x86_64
+            memory: 4096
           - api-level: 36 # Android 16
             target: google_apis
             channel: canary # Necessary for ATDs
             arch: x86_64
+            memory: 4096
           - api-level: "37.0" # Android 17; API 37 ships only as a minor-versioned image
             target: google_apis_ps16k # API 37 has no plain google_apis image
             channel: canary # Necessary for ATDs
             arch: x86_64
+            memory: 8192
     steps:
       - name: Checkout code
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -112,9 +117,9 @@ jobs:
           path: |
             ~/.android/avd/*
             ~/.android/adb*
-          # Keyed on the cmdline-tools version so AVDs created by the old, broken
-          # avdmanager are invalidated automatically.
-          key: avd-api-${{ matrix.api-level }}-${{ matrix.arch }}-${{ matrix.target }}-tools${{ steps.cmdline-tools.outputs.version }}
+          # Keyed on memory and the cmdline-tools version so incompatible snapshots
+          # and AVDs created by the old, broken avdmanager are invalidated automatically.
+          key: avd-api-${{ matrix.api-level }}-${{ matrix.arch }}-${{ matrix.target }}-memory${{ matrix.memory }}-tools${{ steps.cmdline-tools.outputs.version }}
 
       - name: Create AVD and generate snapshot for caching
         if: steps.avd-cache.outputs.cache-hit != 'true'
@@ -127,7 +132,7 @@ jobs:
           force-avd-creation: false
           disable-animations: true
           disable-spellchecker: true
-          emulator-options: -memory 4096 -no-window -gpu auto -noaudio -no-boot-anim -camera-back none
+          emulator-options: -memory ${{ matrix.memory }} -no-window -gpu auto -noaudio -no-boot-anim -camera-back none
           disk-size: 4096M
           script: echo "Generated AVD snapshot for caching."
 
@@ -151,7 +156,7 @@ jobs:
           force-avd-creation: false
           disable-animations: true
           disable-spellchecker: true
-          emulator-options: -memory 4096 -no-window -gpu auto -noaudio -no-boot-anim -camera-back none -no-snapshot-save
+          emulator-options: -memory ${{ matrix.memory }} -no-window -gpu auto -noaudio -no-boot-anim -camera-back none -no-snapshot-save
           script: |
             adb uninstall io.sentry.uitest.android.critical || echo "Already uninstalled (or not found)"
             adb install -r -d "${{env.APK_NAME}}"

From 3dd4c87e658f87d24d2e744b84a82ff6ae4c3d39 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Mon, 27 Jul 2026 13:07:14 +0200
Subject: [PATCH 330/391] perf(json): Avoid exceptions when typing JSON numbers
 (JAVA-536) (#5783)

* perf(json): Avoid exceptions when typing JSON numbers (JAVA-536)

JsonObjectDeserializer typed numbers by calling nextInt() and catching
the NumberFormatException it throws for every non-integer value, then
falling back to nextDouble(). For payloads full of floating-point values
(timestamps, measurements) this threw and filled a stack trace on nearly
every number, dominating the cost of deserializing arbitrary objects.

Parse the value as a double once and narrow it back to an int only when
it is integral and fits, which avoids the throws. Return types are
unchanged (Integer for values that fit an int, Double otherwise), so
callers that read integers out of the generic object tree are unaffected.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../io/sentry/JsonObjectDeserializer.java     | 19 ++++---
 .../io/sentry/JsonObjectDeserializerTest.kt   | 50 +++++++++++++++++++
 3 files changed, 60 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b8fc67b6b53..c2e8119a422 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,7 @@
 ### Performance
 
 - Reduce the number of SDK threads: `LifecycleWatcher` now schedules the session-end task on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5819](https://github.com/getsentry/sentry-java/pull/5819))
+- Speed up deserialization of arbitrary JSON objects by typing numbers without throwing exceptions ([#5783](https://github.com/getsentry/sentry-java/pull/5783))
 
 ## 8.50.1
 
diff --git a/sentry/src/main/java/io/sentry/JsonObjectDeserializer.java b/sentry/src/main/java/io/sentry/JsonObjectDeserializer.java
index 0916f6e82d5..cd1d99d66fb 100644
--- a/sentry/src/main/java/io/sentry/JsonObjectDeserializer.java
+++ b/sentry/src/main/java/io/sentry/JsonObjectDeserializer.java
@@ -172,17 +172,16 @@ private boolean handlePrimitive(NextValue callback) throws IOException {
   }
 
   private Object nextNumber(JsonObjectReader reader) throws IOException {
-    try {
-      return reader.nextInt();
-    } catch (Exception exception) {
-      // Need to try/fail as there are no int/double/long tokens.
+    // JSON has no int/double token distinction. Probing with reader.nextInt() and catching the
+    // NumberFormatException it throws for every non-integer (e.g. timestamps) dominated the cost of
+    // deserializing arbitrary objects. Read once as a double and narrow to an int only when the
+    // value is integral and fits, which reproduces the previous return types without any throws.
+    final double value = reader.nextDouble();
+    final int intValue = (int) value;
+    if (intValue == value) {
+      return intValue;
     }
-    try {
-      return reader.nextDouble();
-    } catch (Exception exception) {
-      // Need to try/fail as there are no int/double/long tokens.
-    }
-    return reader.nextLong();
+    return value;
   }
 
   private @Nullable Token getCurrentToken() {
diff --git a/sentry/src/test/java/io/sentry/JsonObjectDeserializerTest.kt b/sentry/src/test/java/io/sentry/JsonObjectDeserializerTest.kt
index 04e2aaceba0..f2bb1d79044 100644
--- a/sentry/src/test/java/io/sentry/JsonObjectDeserializerTest.kt
+++ b/sentry/src/test/java/io/sentry/JsonObjectDeserializerTest.kt
@@ -1,8 +1,10 @@
 package io.sentry
 
+import java.io.IOException
 import java.io.StringReader
 import java.lang.Exception
 import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
 import kotlin.test.assertNull
 import kotlin.test.fail
 import org.junit.Test
@@ -42,6 +44,54 @@ class JsonObjectDeserializerTest {
     assertEquals(1.1, actual)
   }
 
+  // A value that is integral and fits an int is typed as Integer (regardless of how it was
+  // written); anything else is a Double. This matches the behavior prior to removing the
+  // exception-based number typing.
+
+  @Test
+  fun `deserialize negative int`() {
+    assertEquals(-5, deserialize("-5"))
+  }
+
+  @Test
+  fun `deserialize negative double`() {
+    assertEquals(-3.14, deserialize("-3.14"))
+  }
+
+  @Test
+  fun `deserialize integral exponent notation as int`() {
+    assertEquals(100, deserialize("1e2"))
+    assertEquals(100, deserialize("1E2"))
+  }
+
+  @Test
+  fun `deserialize fractional exponent notation as double`() {
+    assertEquals(0.0025, deserialize("2.5e-3"))
+  }
+
+  @Test
+  fun `deserialize whole-valued decimal as int`() {
+    assertEquals(1, deserialize("1.0"))
+  }
+
+  @Test
+  fun `deserialize integer larger than int range as double`() {
+    assertEquals(1.0e10, deserialize("10000000000"))
+    assertEquals(2147483648.0, deserialize("2147483648"))
+  }
+
+  @Test
+  fun `deserialize max int as int`() {
+    assertEquals(Int.MAX_VALUE, deserialize("2147483647"))
+  }
+
+  @Test
+  fun `deserialize rejects literal overflowing to infinity`() {
+    // Strict JSON forbids non-finite numbers, so an out-of-range literal must fail rather than be
+    // stored as Infinity.
+    assertFailsWith<IOException> { deserialize("1e400") }
+  }
+
   @Test
   fun `deserialize array`() {
     val json = "[\"a\",\"b\"]"

From d928adbde98c6da27c7836b1990411af5e1fb1b1 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 28 Jul 2026 09:07:34 +0200
Subject: [PATCH 331/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.16.0 (#5845)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 ++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c2e8119a422..8cb55637577 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,12 @@
 - Reduce the number of SDK threads: `LifecycleWatcher` now schedules the session-end task on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5819](https://github.com/getsentry/sentry-java/pull/5819))
 - Speed up deserialization of arbitrary JSON objects by typing numbers without throwing exceptions ([#5783](https://github.com/getsentry/sentry-java/pull/5783))
 
+### Dependencies
+
+- Bump Native SDK from v0.15.4 to v0.16.0 ([#5845](https://github.com/getsentry/sentry-java/pull/5845))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0160)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.15.4...0.16.0)
+
 ## 8.50.1
 
 ### Fixes
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 89de8fce039..32bf6b736d9 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -169,7 +169,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.15.4" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.16.0" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From a30048b0fc30280201fdba44a7ab4a91ad98c80a Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Tue, 28 Jul 2026 22:51:51 +0200
Subject: [PATCH 332/391] fix(replay): Post checkCanRecord to main thread to
 prevent deadlock (#5837)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(replay): Post checkCanRecord to main thread to prevent deadlock

onScreenshotRecorded can run on the replay executor thread (PixelCopy
masked-capture and emit paths). checkCanRecord -> pauseInternal acquires
lifecycleLock — if another thread holds that lock and submits to the
same single-threaded executor, we deadlock.

When not already on the main thread, post checkCanRecord to the main
looper so it never runs on the executor. On main thread, call directly
to preserve existing synchronous behavior.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix test

* fix(replay): Move executor shutdown outside lifecycleLock in close()

Holding lifecycleLock while calling awaitTermination() deadlocks if any
executor task tries to acquire the same lock. Move shutdown after the
lock is released to cut this edge.

Ref: #5847

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* chore: Drop ponytail prefix from comment

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* test(replay): Add deadlock test for close() with blocked executor task

Verifies close() completes when an executor task is waiting on
lifecycleLock, ensuring shutdown happens outside the lock.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../android/replay/ReplayIntegration.kt       | 46 ++++++++++------
 .../sentry/android/replay/ReplaySmokeTest.kt  | 54 ++++++++++++++++++-
 3 files changed, 84 insertions(+), 17 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8cb55637577..ef4a9324457 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,7 @@
 
 ### Fixes
 
+- Fix potential ANR/deadlock in Session Replay when `checkCanRecord` runs on the replay executor thread ([#5837](https://github.com/getsentry/sentry-java/pull/5837))
 - Prevent concurrent PixelCopy access during Session Replay masking and bitmap cleanup ([#5808](https://github.com/getsentry/sentry-java/pull/5808))
 - Release `MediaMuxer` when the replay video encoder fails to start to avoid a resource leak ([#5607](https://github.com/getsentry/sentry-java/pull/5607))
 
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
index d9cd15d891a..98333260c7d 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt
@@ -4,6 +4,7 @@ import android.content.Context
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.os.Build
+import android.os.Looper
 import android.view.MotionEvent
 import io.sentry.Breadcrumb
 import io.sentry.DataCategory.All
@@ -130,7 +131,7 @@ public class ReplayIntegration(
   private var replayCaptureStrategyProvider: ((isFullSession: Boolean) -> CaptureStrategy)? = null
   private var mainLooperHandler: MainLooperHandler = MainLooperHandler()
   private var gestureRecorderProvider: (() -> GestureRecorder)? = null
-  private val lifecycleLock = AutoClosableReentrantLock()
+  internal val lifecycleLock = AutoClosableReentrantLock()
   private val lifecycle = ReplayLifecycle()
 
   override fun register(scopes: IScopes, options: SentryOptions) {
@@ -352,7 +353,7 @@ public class ReplayIntegration(
       }
       addFrame(bitmap, frameTimeStamp, screen)
     }
-    checkCanRecord()
+    postOnMainThread { checkCanRecord() }
   }
 
   override fun onScreenshotRecorded(screenshot: File, frameTimestamp: Long) {
@@ -375,7 +376,7 @@ public class ReplayIntegration(
       }
       addFrame(screenshot, frameTimestamp, screen)
     }
-    checkCanRecord()
+    postOnMainThread { checkCanRecord() }
   }
 
   override fun close() {
@@ -390,21 +391,23 @@ public class ReplayIntegration(
       recorder?.close()
       recorder = null
       rootViewsSpy.close()
-      if (lazyReplayExecutor.isInitialized()) {
-        if (options.threadChecker.isMainThread) {
-          replayExecutor.gracefulShutdown()
-        } else {
-          replayExecutor.shutdown()
-        }
+      lifecycle.currentState = CLOSED
+    }
+    // shutdown outside lock — awaiting termination while holding lifecycleLock deadlocks
+    // if any executor task tries to acquire the same lock
+    if (lazyReplayExecutor.isInitialized()) {
+      if (options.threadChecker.isMainThread) {
+        replayExecutor.gracefulShutdown()
+      } else {
+        replayExecutor.shutdown()
       }
-      if (lazyPersistingExecutor.isInitialized()) {
-        if (options.threadChecker.isMainThread) {
-          persistingExecutor.gracefulShutdown()
-        } else {
-          persistingExecutor.shutdown()
-        }
+    }
+    if (lazyPersistingExecutor.isInitialized()) {
+      if (options.threadChecker.isMainThread) {
+        persistingExecutor.gracefulShutdown()
+      } else {
+        persistingExecutor.shutdown()
       }
-      lifecycle.currentState = CLOSED
     }
   }
 
@@ -444,6 +447,17 @@ public class ReplayIntegration(
     captureStrategy?.onTouchEvent(event)
   }
 
+  // Runs [block] on the main thread. If already there, executes inline; otherwise posts via
+  // the main looper handler. Prevents deadlocks when lifecycle-lock-acquiring code (e.g.
+  // checkCanRecord -> pauseInternal) is called from the replay executor thread.
+  private inline fun postOnMainThread(crossinline block: () -> Unit) {
+    if (Looper.myLooper() == Looper.getMainLooper()) {
+      block()
+    } else {
+      mainLooperHandler.post { block() }
+    }
+  }
+
   /**
    * Check if we're offline or rate-limited and pause for session mode to not overflow the envelope
    * cache.
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplaySmokeTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplaySmokeTest.kt
index c26e6be9c41..b5e15b5534f 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplaySmokeTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplaySmokeTest.kt
@@ -23,13 +23,16 @@ import io.sentry.rrweb.RRWebMetaEvent
 import io.sentry.rrweb.RRWebVideoEvent
 import io.sentry.transport.CurrentDateProvider
 import io.sentry.transport.ICurrentDateProvider
+import io.sentry.transport.RateLimiter
 import java.time.Duration
+import java.util.concurrent.CountDownLatch
 import java.util.concurrent.Executors
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.test.BeforeTest
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
 import org.awaitility.core.ConditionTimeoutException
 import org.awaitility.kotlin.await
 import org.junit.Rule
@@ -41,6 +44,7 @@ import org.mockito.kotlin.any
 import org.mockito.kotlin.anyOrNull
 import org.mockito.kotlin.check
 import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
@@ -61,11 +65,17 @@ class ReplaySmokeTest {
   internal class Fixture {
     val options = SentryOptions()
     val scope = Scope(options)
+    val rateLimiter =
+      mock<RateLimiter> {
+        on { isActiveForCategory(any()) }.thenReturn(false)
+      }
     val scopes =
       mock<IScopes> {
         doAnswer { (it.arguments[0] as ScopeCallback).run(scope) }
           .whenever(it)
           .configureScope(any())
+
+        on { rateLimiter }.doReturn(rateLimiter)
       }
 
     private class ImmediateHandler :
@@ -91,7 +101,10 @@ class ReplaySmokeTest {
         mainLooperHandler =
           mock {
             whenever(mock.handler).thenReturn(ImmediateHandler())
-            whenever(mock.post(any())).then { (it.arguments[0] as Runnable).run() }
+            whenever(mock.post(any())).then {
+              (it.arguments[0] as Runnable).run()
+              true
+            }
             whenever(mock.postDelayed(any(), anyLong())).then {
               // have to use another thread here otherwise it will block the test thread
               recordingThread.schedule(
@@ -243,6 +256,45 @@ class ReplaySmokeTest {
     assertNotEquals(falseReplay.rootViewsSpy, replay.rootViewsSpy)
     assertEquals(0, falseReplay.rootViewsSpy.listeners.size)
   }
+
+  @Test
+  fun `close does not deadlock when executor task is waiting on lifecycleLock`() {
+    fixture.options.sessionReplay.sessionSampleRate = 1.0
+    fixture.options.cacheDirPath = tmpDir.newFolder().absolutePath
+
+    val replay = fixture.getSut(context)
+    replay.register(fixture.scopes, fixture.options)
+    replay.start()
+
+    val taskBlocked = CountDownLatch(1)
+    val lockReleased = CountDownLatch(1)
+
+    // hold lifecycleLock on this thread
+    val token = replay.lifecycleLock.acquire()
+
+    // submit a task on the executor that tries to acquire the same lock — it will block
+    replay.replayExecutor.submit {
+      taskBlocked.countDown()
+      replay.lifecycleLock.acquire().use {}
+    }
+
+    // wait for the executor task to actually be running and blocked
+    assertTrue(taskBlocked.await(2, TimeUnit.SECONDS))
+
+    // release the lock, then close — if shutdown were inside the lock this would deadlock
+    token.close()
+
+    // close() must complete within a reasonable time
+    val closedInTime = AtomicBoolean(false)
+    val closeThread = Thread {
+      replay.close()
+      closedInTime.set(true)
+    }
+    closeThread.start()
+    closeThread.join(5000)
+
+    assertTrue(closedInTime.get(), "close() deadlocked")
+  }
 }
 
 private class ExampleActivity : Activity() {

From 02b196f8d027c6653ca4f1704741e91987f33fa9 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 29 Jul 2026 10:36:08 +0200
Subject: [PATCH 333/391] fix(replay): Skip buffer-mode replay capture when
 rate-limited (DART-313) (#5813)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(replay): Skip buffer-mode replay capture when rate-limited (DART-313)

In buffer (on-error) mode the recorder keeps running while rate-limited so
the rolling buffer stays warm, but capturing on an error still encoded the
current and buffered segments and handed them to the transport, which then
dropped them. That wasted CPU, I/O, and MediaMuxer file descriptors on
envelopes that could never be sent.

Bail out of BufferCaptureStrategy.captureReplay when the Replay (or All)
category is rate-limited, mirroring the guard session mode already applies.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* changelog

* fix(replay): Record a lost replay event when buffer capture is rate-limited (DART-313)

Skipping the encode when rate-limited meant the segments never reached the
transport, so RateLimiter.filter never recorded them as lost. Replay drops in
buffer mode silently vanished from client reports.

Record a RATELIMIT_BACKOFF lost event for the Replay category at the bail-out,
and move the rate-limit check below the sampling and isTerminating guards so we
only report replays that would genuinely have been sent — a replay dropped by
onErrorSampleRate is not a rate-limit loss, and a terminating one is deferred to
the next launch rather than lost.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* changelog

* fix(replay): Keep buffer mode while rate-limited (DART-313)

Bailing out of BufferCaptureStrategy.captureReplay while rate-limited left
isTerminating unset, so ReplayIntegration's unconditional convert() still
swapped in a SessionCaptureStrategy. That discarded the rolling buffer, and
the next recorded frame then hit checkCanRecord(), which pauses session mode
when rate-limited and encodes a segment on the way out - exactly the work the
bail-out was meant to avoid. It also left recording paused for the rest of the
rate-limit window, contradicting onRateLimitChanged, which deliberately keeps
buffer mode running.

Stay in buffer mode while rate-limited so the buffer keeps rolling and the
next error after the limit expires can send a complete replay.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  3 +
 .../replay/capture/BufferCaptureStrategy.kt   | 27 +++++++
 .../capture/BufferCaptureStrategyTest.kt      | 75 +++++++++++++++++++
 3 files changed, 105 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ef4a9324457..2aee94a20b4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -37,6 +37,9 @@
 
 ### Fixes
 
+- Skip encoding and capturing buffered session replay segments while rate-limited, so we don't waste resources on envelopes the transport will drop ([#5813](https://github.com/getsentry/sentry-java/pull/5813))
+  - These skipped replays are now reported as `ratelimit_backoff` discarded events in client reports, so they no longer disappear from drop statistics. One event is recorded per buffer flush rather than per segment.
+  - Buffer mode is also kept while rate-limited instead of switching to session mode, so the rolling buffer stays warm and the next error after the rate limit expires can send a complete replay.
 - Reduce main-thread work during `Sentry.init` by resolving the shake-detector accelerometer off the main thread (~1.75ms on a Pixel 10) ([#5784](https://github.com/getsentry/sentry-java/pull/5784))
 - Backfill release, environment, distribution, tags, and app version/build—and use the matching replay-on-error sample rate—for `ApplicationExitInfo` ANR and native crash events captured before SDK initialization, without reusing options cached by a later app update ([#5762](https://github.com/getsentry/sentry-java/pull/5762))
 - `SentryTagModifierNode.isImportantForBounds` now matches the default behavior and returns `true` ([#5789](https://github.com/getsentry/sentry-java/pull/5789))
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
index f6c6f3997ae..1d7bd1c1126 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
@@ -4,6 +4,8 @@ import android.annotation.SuppressLint
 import android.annotation.TargetApi
 import android.graphics.Bitmap
 import android.view.MotionEvent
+import io.sentry.DataCategory.All
+import io.sentry.DataCategory.Replay
 import io.sentry.DateUtils
 import io.sentry.IScopes
 import io.sentry.SentryLevel.DEBUG
@@ -17,6 +19,7 @@ import io.sentry.android.replay.capture.CaptureStrategy.Companion.rotateEvents
 import io.sentry.android.replay.capture.CaptureStrategy.ReplaySegment
 import io.sentry.android.replay.util.ReplayRunnable
 import io.sentry.android.replay.util.sample
+import io.sentry.clientreport.DiscardReason.RATELIMIT_BACKOFF
 import io.sentry.protocol.SentryId
 import io.sentry.transport.ICurrentDateProvider
 import io.sentry.util.FileUtils
@@ -100,6 +103,18 @@ internal class BufferCaptureStrategy(
       return
     }
 
+    if (isReplayRateLimited()) {
+      // the segment envelopes would be dropped by the transport anyway, so don't waste resources
+      // encoding videos that will only be discarded
+      options.logger.log(INFO, "Replay is rate-limited, not capturing for event")
+      // one lost event per flush, not per segment: the transport would have counted the current
+      // segment plus every buffered one, but a flush only ever loses a single replay from the
+      // user's perspective. Under-reporting here is preferable to making replay look like it
+      // dropped data it never held.
+      options.clientReportRecorder.recordLostEvent(RATELIMIT_BACKOFF, Replay)
+      return
+    }
+
     createCurrentSegment("capture_replay") { segment ->
       bufferedSegments.capture()
 
@@ -151,6 +166,13 @@ internal class BufferCaptureStrategy(
       )
       return this
     }
+    if (isReplayRateLimited()) {
+      // captureReplay skipped the flush, so there is nothing to continue in session mode. Staying
+      // in buffer mode keeps the rolling buffer warm, so the next error after the rate limit
+      // expires can send a complete replay starting at segment 0.
+      options.logger.log(DEBUG, "Not converting to session mode, because replay is rate-limited")
+      return this
+    }
     // we hand over replayExecutor and persistingExecutor to the new strategy to preserve order of
     // execution
     val captureStrategy =
@@ -170,6 +192,11 @@ internal class BufferCaptureStrategy(
     rotateEvents(currentEvents, bufferLimit)
   }
 
+  private fun isReplayRateLimited(): Boolean =
+    scopes?.rateLimiter?.let {
+      it.isActiveForCategory(All) || it.isActiveForCategory(Replay)
+    } == true
+
   private fun deleteFile(file: File?) {
     if (file == null) {
       return
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/BufferCaptureStrategyTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/BufferCaptureStrategyTest.kt
index b5048e856ff..fc1981a84b1 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/BufferCaptureStrategyTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/capture/BufferCaptureStrategyTest.kt
@@ -2,9 +2,12 @@ package io.sentry.android.replay.capture
 
 import android.graphics.Bitmap
 import android.view.MotionEvent
+import io.sentry.DataCategory
 import io.sentry.IScopes
 import io.sentry.Scope
 import io.sentry.ScopeCallback
+import io.sentry.SentryEnvelope
+import io.sentry.SentryEnvelopeHeader
 import io.sentry.SentryOptions
 import io.sentry.SentryReplayEvent.ReplayType
 import io.sentry.android.replay.DefaultReplayBreadcrumbConverter
@@ -17,9 +20,12 @@ import io.sentry.android.replay.ReplayCache.Companion.SEGMENT_KEY_TIMESTAMP
 import io.sentry.android.replay.ReplayFrame
 import io.sentry.android.replay.ScreenshotRecorderConfig
 import io.sentry.android.replay.capture.BufferCaptureStrategyTest.Fixture.Companion.VIDEO_DURATION
+import io.sentry.clientreport.DiscardReason
+import io.sentry.clientreport.DiscardedEvent
 import io.sentry.protocol.SentryId
 import io.sentry.transport.CurrentDateProvider
 import io.sentry.transport.ICurrentDateProvider
+import io.sentry.transport.RateLimiter
 import io.sentry.util.Random
 import java.io.File
 import kotlin.test.Test
@@ -93,6 +99,16 @@ class BufferCaptureStrategyTest {
         bitRate = 20_000,
       )
 
+    // client report counts are only readable by draining them onto an envelope
+    fun discardedEvents(): List<DiscardedEvent> =
+      options.clientReportRecorder
+        .attachReportToEnvelope(SentryEnvelope(SentryEnvelopeHeader(), emptyList()))
+        .items
+        .firstOrNull()
+        ?.getClientReport(options.serializer)
+        ?.discardedEvents
+        .orEmpty()
+
     fun getSut(
       onErrorSampleRate: Double = 1.0,
       dateProvider: ICurrentDateProvider = CurrentDateProvider.getInstance(),
@@ -239,6 +255,19 @@ class BufferCaptureStrategyTest {
     assertTrue(converted is BufferCaptureStrategy)
   }
 
+  @Test
+  fun `convert stays in buffer mode when rate-limited`() {
+    val rateLimiter = mock<RateLimiter> { on { isActiveForCategory(any()) }.thenReturn(true) }
+    whenever(fixture.scopes.rateLimiter).thenReturn(rateLimiter)
+    val strategy = fixture.getSut()
+    strategy.start()
+
+    strategy.captureReplay(false) {}
+
+    val converted = strategy.convert()
+    assertTrue(converted is BufferCaptureStrategy)
+  }
+
   @Test
   fun `convert converts to session strategy and sets replayId to scope`() {
     val strategy = fixture.getSut()
@@ -336,6 +365,52 @@ class BufferCaptureStrategyTest {
     assertEquals(SentryId.EMPTY_ID, fixture.scope.replayId)
   }
 
+  @Test
+  fun `captureReplay does not capture segments when rate-limited`() {
+    val rateLimiter = mock<RateLimiter> { on { isActiveForCategory(any()) }.thenReturn(true) }
+    whenever(fixture.scopes.rateLimiter).thenReturn(rateLimiter)
+    val strategy = fixture.getSut()
+    strategy.start()
+    strategy.onConfigurationChanged(fixture.recorderConfig)
+    strategy.pause()
+
+    strategy.captureReplay(false) {}
+
+    // neither the current nor the buffered segment should be sent while rate-limited
+    verify(fixture.scopes, never()).captureReplay(any(), any())
+    // the replayId is still set on the scope so the error that flushed the buffer stays linked to
+    // the replay that gets recorded once the rate limit lifts
+    assertEquals(strategy.currentReplayId, fixture.scope.replayId)
+  }
+
+  @Test
+  fun `captureReplay records a lost replay event when rate-limited`() {
+    val rateLimiter = mock<RateLimiter> { on { isActiveForCategory(any()) }.thenReturn(true) }
+    whenever(fixture.scopes.rateLimiter).thenReturn(rateLimiter)
+    val strategy = fixture.getSut()
+    strategy.start()
+    strategy.onConfigurationChanged(fixture.recorderConfig)
+    strategy.pause()
+
+    strategy.captureReplay(false) {}
+
+    val discarded = fixture.discardedEvents()
+    assertEquals(1, discarded.size)
+    assertEquals(DiscardReason.RATELIMIT_BACKOFF.reason, discarded.first().reason)
+    assertEquals(DataCategory.Replay.category, discarded.first().category)
+  }
+
+  @Test
+  fun `captureReplay does not record a lost replay event when not rate-limited`() {
+    val strategy = fixture.getSut()
+    strategy.start()
+    strategy.onConfigurationChanged(fixture.recorderConfig)
+
+    strategy.captureReplay(false) {}
+
+    assertTrue(fixture.discardedEvents().none { it.category == DataCategory.Replay.category })
+  }
+
   @Test
   fun `captureReplay sets replayId to scope and captures buffered segments`() {
     var called = false

From 11666ec041600710cd261ca216cd7c53a538f7c0 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 29 Jul 2026 10:36:35 +0200
Subject: [PATCH 334/391] docs(replay): Document the two capture strategies
 (#5848)

SessionCaptureStrategy and BufferCaptureStrategy differ only in when a
recorded segment is sent, but nothing at the top of either class said so.
Add a short KDoc to each pointing at the other, covering how the mode is
selected, when segments are sent, and why ReplayIntegration pauses session
mode while buffer mode keeps recording.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../android/replay/capture/BufferCaptureStrategy.kt  | 12 ++++++++++++
 .../android/replay/capture/SessionCaptureStrategy.kt | 11 +++++++++++
 2 files changed, 23 insertions(+)

diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
index 1d7bd1c1126..4d7bcd64cf4 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BufferCaptureStrategy.kt
@@ -28,6 +28,18 @@ import java.io.File
 import java.util.Date
 import java.util.concurrent.ScheduledExecutorService
 
+/**
+ * Records a rolling `errorReplayDuration` window: segments are encoded but held in memory, and
+ * frames and segments older than the window are dropped on every screenshot. Used when the session
+ * is not sampled by `sessionSampleRate` but `onErrorSampleRate` is set.
+ *
+ * Nothing is sent until [captureReplay] flushes the buffer for an error — sampled per error against
+ * `onErrorSampleRate`, unlike session mode which samples once at start. After a successful flush
+ * [convert] hands over to a [SessionCaptureStrategy] so the rest of the session is recorded live.
+ *
+ * Since nothing is in flight, `ReplayIntegration` deliberately keeps this strategy recording while
+ * rate-limited, so the buffer stays warm for when the limit expires.
+ */
 @SuppressLint("UseRequiresApi")
 @TargetApi(26)
 internal class BufferCaptureStrategy(
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/SessionCaptureStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/SessionCaptureStrategy.kt
index d62efb534cc..df6e09b5358 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/SessionCaptureStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/capture/SessionCaptureStrategy.kt
@@ -16,6 +16,17 @@ import io.sentry.util.FileUtils
 import java.util.Date
 import java.util.concurrent.ScheduledExecutorService
 
+/**
+ * Records a full session: segments are encoded and sent continuously, one per
+ * `sessionSegmentDuration`, until the 1h `sessionDuration` deadline. Used when the session is
+ * sampled by `sessionSampleRate`.
+ *
+ * [captureReplay] is a no-op here — there is no buffer to flush, the segment covering the error is
+ * sent like any other. Because envelopes are in flight the whole time, `ReplayIntegration` pauses
+ * this strategy while offline or rate-limited so the envelope cache doesn't overflow.
+ *
+ * See [BufferCaptureStrategy] for the on-error counterpart.
+ */
 internal class SessionCaptureStrategy(
   private val options: SentryOptions,
   private val scopes: IScopes?,

From d1f9ed43faaa55946372d9a0f2553c7315fa4509 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 29 Jul 2026 11:20:31 +0200
Subject: [PATCH 335/391] chore(deps): bump the github-actions group across 1
 directory with 3 updates (#5850)

Bumps the github-actions group with 3 updates in the / directory: [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft), [saucelabs/saucectl-run-action](https://github.com/saucelabs/saucectl-run-action) and [getsentry/craft](https://github.com/getsentry/craft).


Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.26.14 to 2.27.0
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/cdb657d4bbc70cd497876ad158984b4d345a48ae...667b5f5669552a35990a11ff6ac1131febb07446)

Updates `saucelabs/saucectl-run-action` from 4.4.0 to 4.5.0
- [Release notes](https://github.com/saucelabs/saucectl-run-action/releases)
- [Commits](https://github.com/saucelabs/saucectl-run-action/compare/bc81720eb01738d9c664b07fe42621bd0014283f...283660aa934c02723c497efa151d582a3acc5801)

Updates `getsentry/craft` from 2.26.14 to 2.27.0
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/cdb657d4bbc70cd497876ad158984b4d345a48ae...667b5f5669552a35990a11ff6ac1131febb07446)

---
updated-dependencies:
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.27.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: saucelabs/saucectl-run-action
  dependency-version: 4.5.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: getsentry/craft
  dependency-version: 2.27.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/changelog-preview.yml            | 2 +-
 .github/workflows/integration-tests-benchmarks.yml | 4 ++--
 .github/workflows/integration-tests-ui.yml         | 2 +-
 .github/workflows/release.yml                      | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index 27f1d0006e4..0bfa9bb2d03 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@cdb657d4bbc70cd497876ad158984b4d345a48ae # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@667b5f5669552a35990a11ff6ac1131febb07446 # v2
     secrets: inherit
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 6b0c074f9da..199d22122df 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -48,7 +48,7 @@ jobs:
         run: make assembleBenchmarks
 
       - name: Run All Tests in SauceLab
-        uses: saucelabs/saucectl-run-action@bc81720eb01738d9c664b07fe42621bd0014283f # pin@v3
+        uses: saucelabs/saucectl-run-action@283660aa934c02723c497efa151d582a3acc5801 # pin@v3
         if: github.event_name != 'pull_request' && env.SAUCE_USERNAME != null
         env:
           GITHUB_TOKEN: ${{ github.token }}
@@ -58,7 +58,7 @@ jobs:
           config-file: .sauce/sentry-uitest-android-benchmark.yml
 
       - name: Run one test in SauceLab
-        uses: saucelabs/saucectl-run-action@bc81720eb01738d9c664b07fe42621bd0014283f # pin@v3
+        uses: saucelabs/saucectl-run-action@283660aa934c02723c497efa151d582a3acc5801 # pin@v3
         if: github.event_name == 'pull_request' && env.SAUCE_USERNAME != null
         env:
           GITHUB_TOKEN: ${{ github.token }}
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index da46b859a14..0241cb07536 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -43,7 +43,7 @@ jobs:
         run: make assembleUiTests
 
       - name: Install SauceLabs CLI
-        uses: saucelabs/saucectl-run-action@bc81720eb01738d9c664b07fe42621bd0014283f # pin@v4.4.0
+        uses: saucelabs/saucectl-run-action@283660aa934c02723c497efa151d582a3acc5801 # pin@v4.5.0
         env:
           GITHUB_TOKEN: ${{ github.token }}
         with:
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 85850dd578b..704734bcbaa 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@cdb657d4bbc70cd497876ad158984b4d345a48ae # v2
+        uses: getsentry/craft@667b5f5669552a35990a11ff6ac1131febb07446 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From c318acd31c312df97780dc68ba96671cd0ae3be2 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 29 Jul 2026 13:11:30 +0200
Subject: [PATCH 336/391] perf: Schedule rate-limit notifications on shared
 executor (JAVA-653) (#5814)

* perf: Schedule rate-limit notifications on shared executor (JAVA-653)

RateLimiter created a java.util.Timer whose thread stayed alive forever
once the SDK got rate limited. Schedule the "rate limit lifted"
observer notification on the shared timer executor instead, whose
single worker thread is reused across all timeouts and self-terminates
when idle. Pending notifications are cancelled on close().

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../java/io/sentry/transport/RateLimiter.java | 57 +++++++++++--------
 .../io/sentry/transport/RateLimiterTest.kt    | 35 ++++++++----
 3 files changed, 58 insertions(+), 35 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2aee94a20b4..a964d4032c0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@
 ### Performance
 
 - Reduce the number of SDK threads: `LifecycleWatcher` now schedules the session-end task on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5819](https://github.com/getsentry/sentry-java/pull/5819))
+- Reduce the number of SDK threads: `RateLimiter` now schedules its rate-limit-lifted notifications on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5814](https://github.com/getsentry/sentry-java/pull/5814))
 - Speed up deserialization of arbitrary JSON objects by typing numbers without throwing exceptions ([#5783](https://github.com/getsentry/sentry-java/pull/5783))
 
 ### Dependencies
diff --git a/sentry/src/main/java/io/sentry/transport/RateLimiter.java b/sentry/src/main/java/io/sentry/transport/RateLimiter.java
index a0cd96abba9..dfbc4cb2622 100644
--- a/sentry/src/main/java/io/sentry/transport/RateLimiter.java
+++ b/sentry/src/main/java/io/sentry/transport/RateLimiter.java
@@ -23,12 +23,13 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Date;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Timer;
-import java.util.TimerTask;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -42,8 +43,9 @@ public final class RateLimiter implements Closeable {
   private final @NotNull Map<DataCategory, @NotNull Date> sentryRetryAfterLimit =
       new ConcurrentHashMap<>();
   private final @NotNull List<IRateLimitObserver> rateLimitObservers = new CopyOnWriteArrayList<>();
-  private @Nullable Timer timer = null;
-  private final @NotNull AutoClosableReentrantLock timerLock = new AutoClosableReentrantLock();
+  private final @NotNull List<Future<?>> notifyObserversFutures = new ArrayList<>();
+  private final @NotNull AutoClosableReentrantLock notifyFuturesLock =
+      new AutoClosableReentrantLock();
 
   public RateLimiter(
       final @NotNull ICurrentDateProvider currentDateProvider,
@@ -278,11 +280,11 @@ public void updateRetryAfterLimits(
                   continue;
                 }
 
-                applyRetryAfterOnlyIfLonger(dataCategory, date);
+                applyRetryAfterOnlyIfLonger(dataCategory, date, retryAfterMillis);
               }
             } else {
               // if categories are empty, we should apply to "all" categories.
-              applyRetryAfterOnlyIfLonger(DataCategory.All, date);
+              applyRetryAfterOnlyIfLonger(DataCategory.All, date, retryAfterMillis);
             }
           }
         }
@@ -291,7 +293,7 @@ public void updateRetryAfterLimits(
       final long retryAfterMillis = parseRetryAfterOrDefault(retryAfterHeader);
       // we dont care if Date is UTC as we just add the relative seconds
       final Date date = new Date(currentDateProvider.getCurrentTimeMillis() + retryAfterMillis);
-      applyRetryAfterOnlyIfLonger(DataCategory.All, date);
+      applyRetryAfterOnlyIfLonger(DataCategory.All, date, retryAfterMillis);
     }
   }
 
@@ -300,10 +302,11 @@ public void updateRetryAfterLimits(
    *
    * @param dataCategory the DataCategory
    * @param date the Date to be applied
+   * @param delayMillis the millis until the rate limit is lifted
    */
   @SuppressWarnings({"JdkObsolete", "JavaUtilDate"})
   private void applyRetryAfterOnlyIfLonger(
-      final @NotNull DataCategory dataCategory, final @NotNull Date date) {
+      final @NotNull DataCategory dataCategory, final @NotNull Date date, final long delayMillis) {
     final Date oldDate = sentryRetryAfterLimit.get(dataCategory);
 
     // only overwrite its previous date if the limit is even longer
@@ -312,19 +315,25 @@ private void applyRetryAfterOnlyIfLonger(
 
       notifyRateLimitObservers();
 
-      try (final @NotNull ISentryLifecycleToken ignored = timerLock.acquire()) {
-        if (timer == null) {
-          timer = new Timer(true);
+      // notify observers again once the rate limit is lifted, using the shared timer executor
+      // instead of a dedicated Timer thread
+      try (final @NotNull ISentryLifecycleToken ignored = notifyFuturesLock.acquire()) {
+        final @NotNull Iterator<Future<?>> iterator = notifyObserversFutures.iterator();
+        while (iterator.hasNext()) {
+          if (iterator.next().isDone()) {
+            iterator.remove();
+          }
+        }
+        try {
+          notifyObserversFutures.add(
+              options
+                  .getTimerExecutorService()
+                  .schedule(this::notifyRateLimitObservers, delayMillis));
+        } catch (RejectedExecutionException e) {
+          options
+              .getLogger()
+              .log(SentryLevel.WARNING, "Failed to schedule rate limit lifted notification.", e);
         }
-
-        timer.schedule(
-            new TimerTask() {
-              @Override
-              public void run() {
-                notifyRateLimitObservers();
-              }
-            },
-            date);
       }
     }
   }
@@ -364,11 +373,11 @@ public void removeRateLimitObserver(@NotNull final IRateLimitObserver observer)
 
   @Override
   public void close() throws IOException {
-    try (final @NotNull ISentryLifecycleToken ignored = timerLock.acquire()) {
-      if (timer != null) {
-        timer.cancel();
-        timer = null;
+    try (final @NotNull ISentryLifecycleToken ignored = notifyFuturesLock.acquire()) {
+      for (Future<?> future : notifyObserversFutures) {
+        future.cancel(false);
       }
+      notifyObserversFutures.clear();
     }
     rateLimitObservers.clear();
   }
diff --git a/sentry/src/test/java/io/sentry/transport/RateLimiterTest.kt b/sentry/src/test/java/io/sentry/transport/RateLimiterTest.kt
index 33cda17106f..36927df97dd 100644
--- a/sentry/src/test/java/io/sentry/transport/RateLimiterTest.kt
+++ b/sentry/src/test/java/io/sentry/transport/RateLimiterTest.kt
@@ -18,6 +18,7 @@ import io.sentry.SentryEnvelope
 import io.sentry.SentryEnvelopeHeader
 import io.sentry.SentryEnvelopeItem
 import io.sentry.SentryEvent
+import io.sentry.SentryExecutorService
 import io.sentry.SentryLogEvent
 import io.sentry.SentryLogEvents
 import io.sentry.SentryLogLevel
@@ -37,12 +38,12 @@ import io.sentry.protocol.SentryId
 import io.sentry.protocol.SentryTransaction
 import io.sentry.protocol.User
 import io.sentry.test.getProperty
-import io.sentry.test.injectForField
 import io.sentry.util.HintUtils
 import java.io.File
-import java.util.Timer
 import java.util.UUID
+import java.util.concurrent.Future
 import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.test.AfterTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -63,9 +64,14 @@ class RateLimiterTest {
     val currentDateProvider = mock<ICurrentDateProvider>()
     val clientReportRecorder = mock<IClientReportRecorder>()
     val serializer = mock<ISerializer>()
+    var executorService: SentryExecutorService? = null
 
     fun getSUT(): RateLimiter {
       val options = SentryOptions().apply { setLogger(NoOpLogger.getInstance()) }
+      // a real executor so scheduled rate-limit-lifted notifications actually run
+      val timerExecutorService = SentryExecutorService(options)
+      executorService = timerExecutorService
+      options.setTimerExecutorService(timerExecutorService)
 
       SentryOptionsManipulator.setClientReportRecorder(options, clientReportRecorder)
 
@@ -75,6 +81,12 @@ class RateLimiterTest {
 
   private val fixture = Fixture()
 
+  @AfterTest
+  fun `tear down`() {
+    // the executor's core thread never times out, so it would stay parked for the whole test JVM
+    fixture.executorService?.close(0)
+  }
+
   @Test
   fun `uses X-Sentry-Rate-Limit and allows sending if time has passed`() {
     val rateLimiter = fixture.getSUT()
@@ -654,7 +666,7 @@ class RateLimiterTest {
   }
 
   @Test
-  fun `apply rate limits schedules a timer to notify observers of lifted limits`() {
+  fun `apply rate limits schedules a task to notify observers of lifted limits`() {
     val rateLimiter = fixture.getSUT()
     whenever(fixture.currentDateProvider.currentTimeMillis).thenReturn(0, 1, 2001)
 
@@ -667,18 +679,19 @@ class RateLimiterTest {
   }
 
   @Test
-  fun `close cancels the timer`() {
+  fun `close cancels pending notify tasks`() {
     val rateLimiter = fixture.getSUT()
-    val timer = mock<Timer>()
-    rateLimiter.injectForField("timer", timer)
+    rateLimiter.updateRetryAfterLimits("60:replay:key", null, 1)
+
+    val futures = rateLimiter.getProperty<List<Future<*>>>("notifyObserversFutures")
+    assertEquals(1, futures.size)
+    val future = futures.first()
 
     // When the rate limiter is closed
     rateLimiter.close()
 
-    // Then the timer is cancelled
-    verify(timer).cancel()
-
-    // And is removed by the rateLimiter
-    assertNull(rateLimiter.getProperty("timer"))
+    // Then the pending notify task is cancelled and dropped
+    assertTrue(future.isCancelled)
+    assertTrue(rateLimiter.getProperty<List<Future<*>>>("notifyObserversFutures").isEmpty())
   }
 }

From 5e6844d5bf31f111114fff069ede6a7f12e87b3f Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 29 Jul 2026 13:24:22 +0200
Subject: [PATCH 337/391] perf(core): Create outbox and cache dirs lazily
 instead of during init (JAVA-613) (#5792)

* perf(core): Create outbox and cache dirs lazily instead of during init (JAVA-613)

Sentry.initConfigurations created the outbox and cache directories
synchronously on the init thread, which on Android is the main thread.

Create each directory lazily in its consumer instead: the cache dir on
the first envelope write (transport thread), and the outbox dir in the
file-observer integration (executor thread) and before writing the
startup-crash marker. The native SDK already creates the outbox dir
itself during sentry_init, so NDK crash writes are unaffected.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* ref(core): Encapsulate lazy dir creation in a LazyDirectory value object (JAVA-613)

Replace the duplicated "create the dir if it does not exist" idiom in the
envelope cache, outbox file observer, and startup-crash-marker paths with a
single LazyDirectory type that materializes the directory on first access.

CacheStrategy now owns its directory as a LazyDirectory: write paths call
getOrCreate(), while path-building and validity checks use getFile() so they
do not create the directory as a side effect.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* ref(core): Inject the cache LazyDirectory via the constructor (JAVA-613)

Have the composition roots (EnvelopeCache.create and AndroidEnvelopeCache)
build the LazyDirectory and pass it into CacheStrategy, so the cache no
longer constructs its own directory collaborator from a path string. The
public String constructor is kept and delegates, preserving binary
compatibility.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(core): Create the outbox dir in external envelope writers (JAVA-613)

Creating the outbox dir lazily moved the mkdirs() off the init thread onto
the SDK executor, so the dir is no longer guaranteed to exist once
Sentry.init returns. Writers that drop envelopes into the outbox
themselves raced that executor task and could fail with ENOENT, which is
what EnvelopeTests.sendsNativeTransaction hit on a slow emulator.

Have both external writers create the dir before writing, and document on
getOutboxPath that the directory is created lazily so hybrid SDKs writing
envelopes directly know they have to do the same.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(core): Create the cache dir before writing app-start config (JAVA-613)

The removed init-time mkdirs() ran on the dsn-hashed cache path and created
the un-hashed parent as a side effect. handleAppStartProfilingConfig writes
app_start_profiling_config into that parent via createNewFile(), which fails
with IOException when the parent is missing, and the surrounding catch
swallows it into a log line. The next launch then finds no config and cannot
start app-start profiling.

This was masked because the profiling traces dir still calls mkdirs() on
<cacheDir>/<dsnHash>/profiling_traces, creating the un-hashed grandparent --
but only when profiling is enabled, which every existing test did. The new
test leaves profiling off so nothing else materializes the dir.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* ref(core): Simplify the lazy directory creation helpers (JAVA-613)

The LazyDirectory value object was doing two unrelated jobs: holding a
directory that a long-lived cache creates on first write, and acting as a
one-shot mkdirs() helper at three call sites that constructed it only to
discard it immediately.

Split those apart. FileUtils.createDirectory covers the one-shot case and
returns whether the directory exists afterwards, so the callers log the
failure instead of discarding mkdirs()' return value and failing later in
an unrelated-looking write. LazyDirectory keeps only the cache use and
gains resolve(), which creates the parent before returning the child, so
write paths no longer depend on an earlier getOrCreate() call having run.

Creation is deliberately not cached: on Android the cache dir lives under
Context.getCacheDir(), which the system may wipe at any time, so each
write re-checks and the directory heals itself.

Also revert the LazyDirectory injection into CacheStrategy. Nothing
injected a custom instance, so it only added a public EnvelopeCache
constructor to the API surface for an internal change.

* fix(core): Report success when losing the createDirectory race (JAVA-613)

File.mkdirs() returns false both when it cannot create the directory and
when another thread got there first, so createDirectory reported a failure
for a directory that was present. Callers act on that by skipping their
write: a startup crash would go unmarked and the app-start profiling config
would not be written, even though the directory existed.

Re-check for the directory when mkdirs() fails, which separates losing the
race from a genuine failure such as missing permissions.

The added test fails reliably without the fix, with most of the racing
threads observing false.

* fix(core): Don't recreate the cache dir when discarding (JAVA-613)

getCurrentFile went through LazyDirectory.resolve, which creates the
directory as a side effect. discard() calls it while deleting from the
cache, so discarding an envelope could resurrect a cache dir that had
just been removed.

Compute the path without touching the filesystem instead, and drop
resolve entirely: the remaining write paths already call getOrCreate
once before writing.

* docs(core): Note the lazy dir creation as a behavioral change (JAVA-613)

Sentry.init used to mkdirs() the outbox and cache dirs synchronously, so
both were guaranteed to exist once it returned. They are now created by
whichever component first writes into them, off the init thread, which
breaks anyone writing envelopes into the outbox path directly instead of
going through the SDK -- notably the hybrid SDKs' captureEnvelope.

Call that out under Behavioral Changes so hybrid maintainers see it; the
existing Performance entry only describes the win, not the cost.

* docs(core): Explain why LazyDirectory swallows a failed mkdirs (JAVA-613)

getOrCreate() ignoring the return value of createDirectory() reads like
an oversight next to the callers that do log it, so record that write
paths already surface the failure via their own error handling.

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  7 +++
 .../core/EnvelopeFileObserverIntegration.java |  8 +++
 .../core/cache/AndroidEnvelopeCache.java      | 11 +++-
 .../EnvelopeFileObserverIntegrationTest.kt    | 17 +++++++
 .../core/cache/AndroidEnvelopeCacheTest.kt    | 14 ++++++
 .../uitest/android/critical/MainActivity.kt   |  3 ++
 .../io/sentry/uitest/android/EnvelopeTests.kt |  7 ++-
 sentry/api/sentry.api                         |  7 +++
 sentry/src/main/java/io/sentry/Sentry.java    | 22 ++++----
 .../main/java/io/sentry/SentryOptions.java    |  6 ++-
 .../java/io/sentry/cache/CacheStrategy.java   | 14 +++---
 .../java/io/sentry/cache/EnvelopeCache.java   | 17 +++++--
 .../main/java/io/sentry/util/FileUtils.java   | 16 ++++++
 .../java/io/sentry/util/LazyDirectory.java    | 38 ++++++++++++++
 sentry/src/test/java/io/sentry/SentryTest.kt  | 34 +++++++++----
 .../java/io/sentry/cache/EnvelopeCacheTest.kt | 31 +++++++++++-
 .../test/java/io/sentry/util/FileUtilsTest.kt | 50 +++++++++++++++++++
 .../java/io/sentry/util/LazyDirectoryTest.kt  | 45 +++++++++++++++++
 18 files changed, 311 insertions(+), 36 deletions(-)
 create mode 100644 sentry/src/main/java/io/sentry/util/LazyDirectory.java
 create mode 100644 sentry/src/test/java/io/sentry/util/LazyDirectoryTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a964d4032c0..147172de532 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+### Behavioral Changes
+
+- The outbox and cache directories are no longer created by `Sentry.init` ([#5792](https://github.com/getsentry/sentry-java/pull/5792))
+  - They are now created lazily by whichever component first writes into them, off the init thread. As a result, the directories at `SentryOptions.getOutboxPath()` and `SentryOptions.getCacheDirPath()` are not guaranteed to exist once `Sentry.init` returns.
+  - If you write envelopes into the outbox path yourself instead of going through the SDK — as hybrid SDKs do for `captureEnvelope` — create the directory first, e.g. `new File(outboxPath).mkdirs()`.
+
 ### Improvements
 
 - Skip building Android manifest metadata debug log messages when debug logging is disabled, reducing allocations during SDK init ([#5790](https://github.com/getsentry/sentry-java/pull/5790))
@@ -14,6 +20,7 @@
 
 ### Performance
 
+- Create the outbox and cache directories lazily in their consumers instead of during SDK init, moving the `mkdirs()` calls off the init (main) thread ([#5792](https://github.com/getsentry/sentry-java/pull/5792))
 - Reduce the number of SDK threads: `LifecycleWatcher` now schedules the session-end task on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5819](https://github.com/getsentry/sentry-java/pull/5819))
 - Reduce the number of SDK threads: `RateLimiter` now schedules its rate-limit-lifted notifications on the shared timer executor instead of creating a dedicated `java.util.Timer` thread ([#5814](https://github.com/getsentry/sentry-java/pull/5814))
 - Speed up deserialization of arbitrary JSON objects by typing numbers without throwing exceptions ([#5783](https://github.com/getsentry/sentry-java/pull/5783))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/EnvelopeFileObserverIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/EnvelopeFileObserverIntegration.java
index 482d90c6e6c..ab95ae32daa 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/EnvelopeFileObserverIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/EnvelopeFileObserverIntegration.java
@@ -10,8 +10,10 @@
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
 import io.sentry.util.AutoClosableReentrantLock;
+import io.sentry.util.FileUtils;
 import io.sentry.util.Objects;
 import java.io.Closeable;
+import java.io.File;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
@@ -67,6 +69,12 @@ private void startOutboxSender(
       final @NotNull IScopes scopes,
       final @NotNull SentryOptions options,
       final @NotNull String path) {
+    // Create the outbox dir here (on the executor) so the observer can watch it for envelopes
+    // written by hybrid SDKs, instead of blocking Sentry.init on the mkdirs.
+    if (!FileUtils.createDirectory(new File(path))) {
+      options.getLogger().log(SentryLevel.ERROR, "Failed to create outbox dir %s", path);
+    }
+
     final OutboxSender outboxSender =
         new OutboxSender(
             scopes,
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/cache/AndroidEnvelopeCache.java b/sentry-android-core/src/main/java/io/sentry/android/core/cache/AndroidEnvelopeCache.java
index e1590e47943..1ef02dfdd2c 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/cache/AndroidEnvelopeCache.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/cache/AndroidEnvelopeCache.java
@@ -93,7 +93,7 @@ private boolean storeInternalAndroid(@NotNull SentryEnvelope envelope, @NotNull
 
   @TestOnly
   public @NotNull File getDirectory() {
-    return directory;
+    return directory.getFile();
   }
 
   private void writeStartupCrashMarkerFile() {
@@ -106,7 +106,14 @@ private void writeStartupCrashMarkerFile() {
           .log(DEBUG, "Outbox path is null, the startup crash marker file will not be written");
       return;
     }
-    final File crashMarkerFile = new File(outboxPath, STARTUP_CRASH_MARKER_FILE);
+    // The outbox dir is no longer created during Sentry.init, so create it here in case the native
+    // SDK (which normally creates it) is disabled.
+    final File outboxDir = new File(outboxPath);
+    if (!FileUtils.createDirectory(outboxDir)) {
+      options.getLogger().log(ERROR, "Failed to create outbox dir %s", outboxPath);
+      return;
+    }
+    final File crashMarkerFile = new File(outboxDir, STARTUP_CRASH_MARKER_FILE);
     try {
       crashMarkerFile.createNewFile();
     } catch (Throwable e) {
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/EnvelopeFileObserverIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/EnvelopeFileObserverIntegrationTest.kt
index 97276d67566..0b13f4ca4d8 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/EnvelopeFileObserverIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/EnvelopeFileObserverIntegrationTest.kt
@@ -14,6 +14,8 @@ import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
@@ -122,4 +124,19 @@ class EnvelopeFileObserverIntegrationTest {
     verify(fixture.logger)
       .log(eq(SentryLevel.DEBUG), eq("EnvelopeFileObserverIntegration installed."))
   }
+
+  @Test
+  fun `register creates the outbox dir when it does not exist yet`() {
+    val outboxDir = File(file, "outbox")
+    assertFalse(outboxDir.exists())
+
+    fixture.getSut { it.executorService = ImmediateExecutorService() }
+    val integration =
+      object : EnvelopeFileObserverIntegration() {
+        override fun getPath(options: SentryOptions): String = outboxDir.absolutePath
+      }
+    integration.register(fixture.scopes, fixture.scopes.options)
+
+    assertTrue(outboxDir.isDirectory)
+  }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/cache/AndroidEnvelopeCacheTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/cache/AndroidEnvelopeCacheTest.kt
index 09d3a779df0..a4063ccb148 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/cache/AndroidEnvelopeCacheTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/cache/AndroidEnvelopeCacheTest.kt
@@ -125,6 +125,20 @@ class AndroidEnvelopeCacheTest {
     assertTrue(fixture.startupCrashMarkerFile.exists())
   }
 
+  @Test
+  fun `creates outbox dir when writing startup crash file and dir does not exist yet`() {
+    val cache = fixture.getSut(dir = tmpDir, appStartMillis = 1000L, currentTimeMillis = 2000L)
+
+    val outboxDir = File(fixture.options.outboxPath!!)
+    assertTrue(outboxDir.deleteRecursively())
+    assertFalse(outboxDir.exists())
+
+    val hints = HintUtils.createWithTypeCheckHint(UncaughtHint())
+    cache.storeEnvelope(fixture.envelope, hints)
+
+    assertTrue(fixture.startupCrashMarkerFile.exists())
+  }
+
   @Test
   fun `when no AnrV2 hint exists, does not write last anr report file`() {
     val cache = fixture.getSut(tmpDir)
diff --git a/sentry-android-integration-tests/sentry-uitest-android-critical/src/main/java/io/sentry/uitest/android/critical/MainActivity.kt b/sentry-android-integration-tests/sentry-uitest-android-critical/src/main/java/io/sentry/uitest/android/critical/MainActivity.kt
index 46bfe7e44b7..7e0ff9d61c3 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-critical/src/main/java/io/sentry/uitest/android/critical/MainActivity.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android-critical/src/main/java/io/sentry/uitest/android/critical/MainActivity.kt
@@ -66,6 +66,9 @@ class MainActivity : ComponentActivity() {
             Button(onClick = { Sentry.close() }) { Text("Close SDK") }
             Button(
               onClick = {
+                // The SDK creates the outbox dir lazily on its executor, so an external
+                // writer has to create it itself.
+                File(outboxPath).mkdirs()
                 val file = File(outboxPath, "corrupted.envelope")
                 val corruptedEnvelopeContent =
                   """
diff --git a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/EnvelopeTests.kt b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/EnvelopeTests.kt
index ade47363296..3fa2c904873 100644
--- a/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/EnvelopeTests.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/EnvelopeTests.kt
@@ -262,9 +262,14 @@ class EnvelopeTests : BaseUiTest() {
       optionsRef = options
     }
 
+    // The SDK creates the outbox dir lazily on its executor, so an external writer racing
+    // Sentry.init has to create it itself.
+    val outboxDir = File(optionsRef!!.outboxPath!!)
+    outboxDir.mkdirs()
+
     // based on
     // https://github.com/getsentry/sentry-native/blob/20d5d5f75f1f48228f2f47e2bb99b17f9996ebbf/ndk/lib/src/androidTest/java/io/sentry/ndk/SentryNdkTest.java#L131
-    File(optionsRef!!.outboxPath, "14779dbf-b2f0-4c00-f4e5-4a287abc4267")
+    File(outboxDir, "14779dbf-b2f0-4c00-f4e5-4a287abc4267")
       .writeText(
         """
         {"dsn":"https://key@sentry.io/proj","event_id":"729ff878-5539-458d-f657-a1acf423a127","sent_at":"2025-04-02T10:02:04.732577Z"}
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index c623e71d08f..14780d1a4b2 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -7692,6 +7692,7 @@ public final class io/sentry/util/ExceptionUtils {
 
 public final class io/sentry/util/FileUtils {
 	public fun <init> ()V
+	public static fun createDirectory (Ljava/io/File;)Z
 	public static fun deleteRecursively (Ljava/io/File;)Z
 	public static fun readBytesFromFile (Ljava/lang/String;J)[B
 	public static fun readText (Ljava/io/File;)Ljava/lang/String;
@@ -7757,6 +7758,12 @@ public final class io/sentry/util/JsonSerializationUtils {
 	public static fun calendarToMap (Ljava/util/Calendar;)Ljava/util/Map;
 }
 
+public final class io/sentry/util/LazyDirectory {
+	public fun <init> (Ljava/lang/String;)V
+	public fun getFile ()Ljava/io/File;
+	public fun getOrCreate ()Ljava/io/File;
+}
+
 public final class io/sentry/util/LazyEvaluator {
 	public fun <init> (Lio/sentry/util/LazyEvaluator$Evaluator;)V
 	public fun getValue ()Ljava/lang/Object;
diff --git a/sentry/src/main/java/io/sentry/Sentry.java b/sentry/src/main/java/io/sentry/Sentry.java
index 8bba9d92e4f..266aa39e793 100644
--- a/sentry/src/main/java/io/sentry/Sentry.java
+++ b/sentry/src/main/java/io/sentry/Sentry.java
@@ -463,8 +463,9 @@ private static void handleAppStartProfilingConfig(
           () -> {
             final String cacheDirPath = options.getCacheDirPathWithoutDsn();
             if (cacheDirPath != null) {
+              final @NotNull File cacheDir = new File(cacheDirPath);
               final @NotNull File appStartProfilingConfigFile =
-                  new File(cacheDirPath, APP_START_PROFILING_CONFIG_FILE_NAME);
+                  new File(cacheDir, APP_START_PROFILING_CONFIG_FILE_NAME);
               try {
                 // We always delete the config file for app start profiling
                 FileUtils.deleteRecursively(appStartProfilingConfigFile);
@@ -481,6 +482,14 @@ private static void handleAppStartProfilingConfig(
                           "Tracing is disabled and app start profiling will not start.");
                   return;
                 }
+                // The cache dir is no longer created during init, so create it here before writing:
+                // createNewFile() fails if the parent is missing.
+                if (!FileUtils.createDirectory(cacheDir)) {
+                  options
+                      .getLogger()
+                      .log(SentryLevel.ERROR, "Failed to create cache dir %s", cacheDirPath);
+                  return;
+                }
                 if (appStartProfilingConfigFile.createNewFile()) {
                   // If old app start profiling is false, it means the transaction will not be
                   // sampled, but we create the file anyway to allow continuous profiling on app
@@ -616,19 +625,14 @@ private static void initConfigurations(final @NotNull SentryOptions options) {
     // TODO: read values from conf file, Build conf or system envs
     // eg release, distinctId, sentryClientName
 
-    // this should be after setting serializers
-    final String outboxPath = options.getOutboxPath();
-    if (outboxPath != null) {
-      final File outboxDir = new File(outboxPath);
-      outboxDir.mkdirs();
-    } else {
+    // The outbox and cache dirs are created lazily by their consumers (envelope cache, outbox file
+    // observer, native SDK) off the init thread, so we don't stat/mkdir them here.
+    if (options.getOutboxPath() == null) {
       logger.log(SentryLevel.INFO, "No outbox dir path is defined in options.");
     }
 
     final String cacheDirPath = options.getCacheDirPath();
     if (cacheDirPath != null) {
-      final File cacheDir = new File(cacheDirPath);
-      cacheDir.mkdirs();
       final IEnvelopeCache envelopeCache = options.getEnvelopeDiskCache();
       // only overwrite the cache impl if it's not already set
       if (envelopeCache instanceof NoOpEnvelopeCache) {
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index f10f2aede05..93104101f81 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -1104,7 +1104,11 @@ String getCacheDirPathWithoutDsn() {
   }
 
   /**
-   * Returns the outbox path if cacheDirPath is set
+   * Returns the outbox path if cacheDirPath is set.
+   *
+   * <p>The directory is created lazily by the SDK on a background thread, so it is not guaranteed
+   * to exist when {@code Sentry.init} returns. Callers writing envelopes here directly (for example
+   * hybrid SDKs) must create it themselves, e.g. {@code new File(outboxPath).mkdirs()}.
    *
    * @return the outbox path or null if not set
    */
diff --git a/sentry/src/main/java/io/sentry/cache/CacheStrategy.java b/sentry/src/main/java/io/sentry/cache/CacheStrategy.java
index 479c0e42eaf..5f3e605f2a1 100644
--- a/sentry/src/main/java/io/sentry/cache/CacheStrategy.java
+++ b/sentry/src/main/java/io/sentry/cache/CacheStrategy.java
@@ -10,6 +10,7 @@
 import io.sentry.SentryOptions;
 import io.sentry.Session;
 import io.sentry.clientreport.DiscardReason;
+import io.sentry.util.LazyDirectory;
 import io.sentry.util.LazyEvaluator;
 import io.sentry.util.Objects;
 import java.io.BufferedInputStream;
@@ -39,7 +40,7 @@ abstract class CacheStrategy {
   protected @NotNull SentryOptions options;
   protected final @NotNull LazyEvaluator<ISerializer> serializer =
       new LazyEvaluator<>(() -> options.getSerializer());
-  protected final @NotNull File directory;
+  protected final @NotNull LazyDirectory directory;
   private final int maxSize;
 
   CacheStrategy(
@@ -48,9 +49,7 @@ abstract class CacheStrategy {
       final int maxSize) {
     Objects.requireNonNull(directoryPath, "Directory is required.");
     this.options = Objects.requireNonNull(options, "SentryOptions is required.");
-
-    this.directory = new File(directoryPath);
-
+    this.directory = new LazyDirectory(directoryPath);
     this.maxSize = maxSize;
   }
 
@@ -60,13 +59,12 @@ abstract class CacheStrategy {
    * @return true if valid and has permissions or false otherwise
    */
   protected boolean isDirectoryValid() {
-    if (!directory.isDirectory() || !directory.canWrite() || !directory.canRead()) {
+    final File dir = directory.getFile();
+    if (!dir.isDirectory() || !dir.canWrite() || !dir.canRead()) {
       options
           .getLogger()
           .log(
-              ERROR,
-              "The directory for caching files is inaccessible.: %s",
-              directory.getAbsolutePath());
+              ERROR, "The directory for caching files is inaccessible.: %s", dir.getAbsolutePath());
       return false;
     }
     return true;
diff --git a/sentry/src/main/java/io/sentry/cache/EnvelopeCache.java b/sentry/src/main/java/io/sentry/cache/EnvelopeCache.java
index 475993bbc1d..618de655478 100644
--- a/sentry/src/main/java/io/sentry/cache/EnvelopeCache.java
+++ b/sentry/src/main/java/io/sentry/cache/EnvelopeCache.java
@@ -109,10 +109,13 @@ public boolean storeEnvelope(final @NotNull SentryEnvelope envelope, final @NotN
   private boolean storeInternal(final @NotNull SentryEnvelope envelope, final @NotNull Hint hint) {
     Objects.requireNonNull(envelope, "Envelope is required.");
 
+    // Create the cache dir lazily on the first write so Sentry.init doesn't block on the mkdirs.
+    final String directoryPath = directory.getOrCreate().getAbsolutePath();
+
     rotateCacheIfNeeded(allEnvelopeFiles());
 
-    final File currentSessionFile = getCurrentSessionFile(directory.getAbsolutePath());
-    final File previousSessionFile = getPreviousSessionFile(directory.getAbsolutePath());
+    final File currentSessionFile = getCurrentSessionFile(directoryPath);
+    final File previousSessionFile = getPreviousSessionFile(directoryPath);
 
     if (HintUtils.hasType(hint, SessionEnd.class)) {
       if (!currentSessionFile.delete()) {
@@ -199,7 +202,7 @@ private boolean storeInternal(final @NotNull SentryEnvelope envelope, final @Not
   @SuppressWarnings("JavaUtilDate")
   private void tryEndPreviousSession(final @NotNull Hint hint) {
     final Object sdkHint = HintUtils.getSentrySdkHint(hint);
-    final File previousSessionFile = getPreviousSessionFile(directory.getAbsolutePath());
+    final File previousSessionFile = getPreviousSessionFile(directory.getFile().getAbsolutePath());
 
     if (previousSessionFile.exists()) {
       options.getLogger().log(WARNING, "Previous session is not ended, we'd need to end it.");
@@ -372,6 +375,10 @@ public void discard(final @NotNull SentryEnvelope envelope) {
    * Returns the envelope's file path. If the envelope wasn't added to the cache beforehand, a
    * random file name is assigned.
    *
+   * <p>This only computes a path and never creates the directory, so that {@link
+   * #discard(SentryEnvelope)} doesn't resurrect a cache dir it is only deleting from. Writers go
+   * through {@link #storeInternal}, which creates the directory up front.
+   *
    * @param envelope the SentryEnvelope object
    * @return the file
    */
@@ -385,7 +392,7 @@ public void discard(final @NotNull SentryEnvelope envelope) {
         fileNameMap.put(envelope, fileName);
       }
 
-      return new File(directory.getAbsolutePath(), fileName);
+      return new File(directory.getFile(), fileName);
     }
   }
 
@@ -431,7 +438,7 @@ public void discard(final @NotNull SentryEnvelope envelope) {
     if (isDirectoryValid()) {
       // lets filter the session.json here
       final File[] files =
-          directory.listFiles((__, fileName) -> fileName.endsWith(SUFFIX_ENVELOPE_FILE));
+          directory.getFile().listFiles((__, fileName) -> fileName.endsWith(SUFFIX_ENVELOPE_FILE));
       if (files != null) {
         return files;
       }
diff --git a/sentry/src/main/java/io/sentry/util/FileUtils.java b/sentry/src/main/java/io/sentry/util/FileUtils.java
index 73b83713c77..337a9a8863d 100644
--- a/sentry/src/main/java/io/sentry/util/FileUtils.java
+++ b/sentry/src/main/java/io/sentry/util/FileUtils.java
@@ -8,6 +8,7 @@
 import java.io.FileReader;
 import java.io.IOException;
 import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 @ApiStatus.Internal
@@ -36,6 +37,21 @@ public static boolean deleteRecursively(@Nullable File file) {
     return file.delete();
   }
 
+  /**
+   * Creates the directory and any missing parents, if it does not exist yet.
+   *
+   * <p>Callers are expected to log a failure: a missing directory otherwise surfaces later as an
+   * unrelated-looking write error.
+   *
+   * @param directory the directory to create
+   * @return true if the directory exists once this returns, false if it could not be created
+   */
+  public static boolean createDirectory(final @NotNull File directory) {
+    // mkdirs() also returns false when another thread created the directory first, so re-check
+    // instead of reporting a failure the caller would act on by skipping its write.
+    return directory.isDirectory() || directory.mkdirs() || directory.isDirectory();
+  }
+
   /**
    * Reads the content of a File into a String. If the file does not exist or is not a file, null is
    * returned. Do not use with large files, as the String is kept in memory!
diff --git a/sentry/src/main/java/io/sentry/util/LazyDirectory.java b/sentry/src/main/java/io/sentry/util/LazyDirectory.java
new file mode 100644
index 00000000000..62334c7665d
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/util/LazyDirectory.java
@@ -0,0 +1,38 @@
+package io.sentry.util;
+
+import java.io.File;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A filesystem directory that is created on demand rather than up front, so the (potentially
+ * blocking) {@code mkdirs()} runs on the thread that first writes into it instead of on the SDK
+ * init thread.
+ *
+ * <p>Read paths should use {@link #getFile()}, which never touches the filesystem. Write paths
+ * should call {@link #getOrCreate()} once before writing. Creation is not cached: on Android the
+ * cache dir lives under {@code Context.getCacheDir()}, which the system may wipe at any time, so
+ * each write re-checks.
+ */
+@ApiStatus.Internal
+public final class LazyDirectory {
+
+  private final @NotNull File file;
+
+  public LazyDirectory(final @NotNull String path) {
+    this.file = new File(path);
+  }
+
+  /** Returns the directory without touching the filesystem. */
+  public @NotNull File getFile() {
+    return file;
+  }
+
+  /** Returns the directory, creating it and any missing parents if it does not exist yet. */
+  public @NotNull File getOrCreate() {
+    // A failed mkdirs is not reported here: callers are write paths, so the failure surfaces as the
+    // write error they already log and report.
+    FileUtils.createDirectory(file);
+    return file;
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/SentryTest.kt b/sentry/src/test/java/io/sentry/SentryTest.kt
index 8d05697fda4..98cda8e9d82 100644
--- a/sentry/src/test/java/io/sentry/SentryTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryTest.kt
@@ -183,7 +183,7 @@ class SentryTest {
   }
 
   @Test
-  fun `outboxPath should be created at initialization`() {
+  fun `outboxPath is not created during initialization`() {
     var sentryOptions: SentryOptions? = null
     initForTest {
       it.dsn = dsn
@@ -191,13 +191,13 @@ class SentryTest {
       sentryOptions = it
     }
 
+    // The outbox dir is created lazily by its consumers (file observer, native SDK), not at init.
     val file = File(sentryOptions!!.outboxPath!!)
-    assertTrue(file.exists())
-    file.deleteOnExit()
+    assertFalse(file.exists())
   }
 
   @Test
-  fun `cacheDirPath should be created at initialization`() {
+  fun `cacheDirPath is not created during initialization`() {
     var sentryOptions: SentryOptions? = null
     initForTest {
       it.dsn = dsn
@@ -205,13 +205,13 @@ class SentryTest {
       sentryOptions = it
     }
 
+    // The cache dir is created lazily on the first envelope store, not at init.
     val file = File(sentryOptions!!.cacheDirPath!!)
-    assertTrue(file.exists())
-    file.deleteOnExit()
+    assertFalse(file.exists())
   }
 
   @Test
-  fun `getCacheDirPathWithoutDsn should be created at initialization`() {
+  fun `cacheDirPathWithoutDsn is not created during initialization`() {
     var sentryOptions: SentryOptions? = null
     initForTest {
       it.dsn = dsn
@@ -221,8 +221,7 @@ class SentryTest {
 
     val cacheDirPathWithoutDsn = sentryOptions!!.cacheDirPathWithoutDsn!!
     val file = File(cacheDirPathWithoutDsn)
-    assertTrue(file.exists())
-    file.deleteOnExit()
+    assertFalse(file.exists())
   }
 
   @Test
@@ -1317,6 +1316,23 @@ class SentryTest {
     assertTrue(appStartProfilingConfigFile.exists())
   }
 
+  @Test
+  fun `init creates app start profiling config when the cache dir does not exist yet`() {
+    val path = getTempPath()
+    // Profiling is left disabled on purpose: it is the only other init-time consumer that creates
+    // the cache dir, so with it off nothing materializes the dir before the config is written.
+    initForTest {
+      it.dsn = dsn
+      it.cacheDirPath = path
+      it.isEnableAppStartProfiling = false
+      it.isStartProfilerOnAppStart = true
+      it.tracesSampleRate = 0.0
+      it.profilesSampleRate = null
+      it.executorService = ImmediateExecutorService()
+    }
+    assertTrue(File(path, "app_start_profiling_config").exists())
+  }
+
   @Test
   fun `init saves SentryAppStartProfilingOptions to disk`() {
     var options = SentryOptions()
diff --git a/sentry/src/test/java/io/sentry/cache/EnvelopeCacheTest.kt b/sentry/src/test/java/io/sentry/cache/EnvelopeCacheTest.kt
index 973070e0afe..dda06ee7e63 100644
--- a/sentry/src/test/java/io/sentry/cache/EnvelopeCacheTest.kt
+++ b/sentry/src/test/java/io/sentry/cache/EnvelopeCacheTest.kt
@@ -79,6 +79,22 @@ class EnvelopeCacheTest {
     file.deleteRecursively()
   }
 
+  @Test
+  fun `creates cache dir on store when it does not exist yet`() {
+    val cache = fixture.getSUT()
+
+    val file = File(fixture.options.cacheDirPath!!)
+    assertTrue(file.deleteRecursively())
+    assertFalse(file.exists())
+
+    cache.store(SentryEnvelope.from(fixture.options.serializer, createSession(), null))
+
+    assertTrue(file.exists())
+    assertEquals(1, file.list()?.size)
+
+    file.deleteRecursively()
+  }
+
   @Test
   fun `tolerates discarding unknown envelope`() {
     val cache = fixture.getSUT()
@@ -88,6 +104,19 @@ class EnvelopeCacheTest {
     // no exception thrown
   }
 
+  @Test
+  fun `does not create cache dir on discard`() {
+    val cache = fixture.getSUT()
+
+    val file = File(fixture.options.cacheDirPath!!)
+    assertTrue(file.deleteRecursively())
+    assertFalse(file.exists())
+
+    cache.discard(SentryEnvelope.from(fixture.options.serializer, createSession(), null))
+
+    assertFalse(file.exists())
+  }
+
   @Test
   fun `creates current file on session start`() {
     val cache = fixture.getSUT()
@@ -450,7 +479,7 @@ class EnvelopeCacheTest {
     cache.store(envelopeA, Hint())
     cache.store(envelopeB, Hint())
 
-    assertEquals(2, cache.directory.list()?.size)
+    assertEquals(2, cache.directory.file.list()?.size)
   }
 
   @Test
diff --git a/sentry/src/test/java/io/sentry/util/FileUtilsTest.kt b/sentry/src/test/java/io/sentry/util/FileUtilsTest.kt
index 65745c0d3d2..60eb092e125 100644
--- a/sentry/src/test/java/io/sentry/util/FileUtilsTest.kt
+++ b/sentry/src/test/java/io/sentry/util/FileUtilsTest.kt
@@ -1,7 +1,10 @@
 package io.sentry.util
 
+import com.google.common.truth.Truth.assertThat
 import java.io.File
 import java.nio.file.Files
+import java.util.concurrent.ConcurrentLinkedQueue
+import java.util.concurrent.CyclicBarrier
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
@@ -73,4 +76,51 @@ class FileUtilsTest {
     f.writeText(text)
     assertEquals(text, FileUtils.readText(f))
   }
+
+  @Test
+  fun `createDirectory creates the directory and any missing parents`() {
+    val dir = File(Files.createTempDirectory("create-dir-test").toFile(), "nested/outbox")
+
+    assertThat(FileUtils.createDirectory(dir)).isTrue()
+    assertThat(dir.isDirectory).isTrue()
+  }
+
+  @Test
+  fun `createDirectory returns true when the directory already exists`() {
+    val dir = Files.createTempDirectory("create-dir-test").toFile()
+
+    assertThat(FileUtils.createDirectory(dir)).isTrue()
+  }
+
+  @Test
+  fun `createDirectory returns false when the directory cannot be created`() {
+    val file = Files.createTempFile("create-dir-test", "test").toFile()
+
+    // a regular file already occupies the path, so it can never become a directory
+    assertThat(FileUtils.createDirectory(file)).isFalse()
+  }
+
+  @Test
+  fun `createDirectory returns true for every caller when threads race to create it`() {
+    val threadCount = 8
+    // mkdirs() returns false for the losers of the race, so every caller must still see success
+    repeat(50) { iteration ->
+      val dir = File(Files.createTempDirectory("create-dir-race").toFile(), "run$iteration/outbox")
+      val barrier = CyclicBarrier(threadCount)
+      val results = ConcurrentLinkedQueue<Boolean>()
+
+      val threads =
+        (1..threadCount).map {
+          Thread {
+            barrier.await()
+            results.add(FileUtils.createDirectory(dir))
+          }
+        }
+      threads.forEach { it.start() }
+      threads.forEach { it.join() }
+
+      assertThat(results).hasSize(threadCount)
+      assertThat(results).doesNotContain(false)
+    }
+  }
 }
diff --git a/sentry/src/test/java/io/sentry/util/LazyDirectoryTest.kt b/sentry/src/test/java/io/sentry/util/LazyDirectoryTest.kt
new file mode 100644
index 00000000000..13e4df001e4
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/util/LazyDirectoryTest.kt
@@ -0,0 +1,45 @@
+package io.sentry.util
+
+import com.google.common.truth.Truth.assertThat
+import java.nio.file.Files
+import kotlin.test.Test
+
+class LazyDirectoryTest {
+  @Test
+  fun `getFile does not create the directory`() {
+    val path = Files.createTempDirectory("lazy-dir-test").resolve("outbox")
+    val lazyDirectory = LazyDirectory(path.toString())
+
+    assertThat(lazyDirectory.file.exists()).isFalse()
+  }
+
+  @Test
+  fun `getOrCreate creates the directory and any missing parents`() {
+    val path = Files.createTempDirectory("lazy-dir-test").resolve("nested").resolve("outbox")
+    val lazyDirectory = LazyDirectory(path.toString())
+
+    val created = lazyDirectory.getOrCreate()
+
+    assertThat(created.isDirectory).isTrue()
+    assertThat(created.absolutePath).isEqualTo(path.toFile().absolutePath)
+  }
+
+  @Test
+  fun `getOrCreate is idempotent when the directory already exists`() {
+    val path = Files.createTempDirectory("lazy-dir-test").resolve("outbox")
+    val lazyDirectory = LazyDirectory(path.toString())
+
+    assertThat(lazyDirectory.getOrCreate().isDirectory).isTrue()
+    assertThat(lazyDirectory.getOrCreate().isDirectory).isTrue()
+  }
+
+  @Test
+  fun `getOrCreate recreates the directory after it is deleted`() {
+    val path = Files.createTempDirectory("lazy-dir-test").resolve("outbox")
+    val lazyDirectory = LazyDirectory(path.toString())
+
+    assertThat(lazyDirectory.getOrCreate().delete()).isTrue()
+
+    assertThat(lazyDirectory.getOrCreate().isDirectory).isTrue()
+  }
+}

From 8f86119357fa53cee9b7cd48c29e6631811d7baf Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Wed, 29 Jul 2026 13:25:31 +0200
Subject: [PATCH 338/391] fix(anr-profiling): Properly bill ANR profiling under
 UI Profile Hours (#5836)

Commit updates the platform used with ANR profiles from Java to Android so that we can properly bill ANR profiling under UI Profile Hours rather than Continuous Profile Hours.

Depends on the updates made in [Relay #6183](https://github.com/getsentry/relay/pull/6183), [getsentry #118849](https://github.com/getsentry/sentry/pull/118849), [vroomrs #93](https://github.com/getsentry/vroomrs/pull/93), and [vroom #672](https://github.com/getsentry/vroom/pull/672).

Co-authored-by: Markus Hintersteiner <markus.hintersteiner@sentry.io>
---
 CHANGELOG.md                                                    | 1 +
 .../sentry/android/core/ApplicationExitInfoEventProcessor.java  | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 147172de532..a01233aebf9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,7 @@
 - Fix potential ANR/deadlock in Session Replay when `checkCanRecord` runs on the replay executor thread ([#5837](https://github.com/getsentry/sentry-java/pull/5837))
 - Prevent concurrent PixelCopy access during Session Replay masking and bitmap cleanup ([#5808](https://github.com/getsentry/sentry-java/pull/5808))
 - Release `MediaMuxer` when the replay video encoder fails to start to avoid a resource leak ([#5607](https://github.com/getsentry/sentry-java/pull/5607))
+- Set the correct platform (`android` instead of `java`) on ANR profile chunks so they are billed as UI Profile Hours rather than Continuous Profile Hours ([#5836](https://github.com/getsentry/sentry-java/pull/5836))
 
 ### Performance
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
index f175db90488..ee07736123b 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
@@ -1021,7 +1021,7 @@ private SentryId captureAnrProfile(final long anrTimestampMs, @NotNull AnrProfil
               null,
               new HashMap<>(0),
               anrTimestampMs / 1000.0d,
-              ProfileChunk.PLATFORM_JAVA,
+              ProfileChunk.PLATFORM_ANDROID,
               options);
       chunk.setSentryProfile(profile);
 

From 91e71acbcd4c29fee08eeb9960d981215d7f2dfe Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 29 Jul 2026 14:56:50 +0200
Subject: [PATCH 339/391] build: Upgrade Gradle to 9.6.1 (#5863)

Keeps the build on the latest Gradle patch release.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 gradle/wrapper/gradle-wrapper.properties | 2 +-
 gradlew                                  | 4 ++--
 gradlew.bat                              | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index df6a6ad763d..a9db11550c6 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.6.1-bin.zip
 networkTimeout=10000
 retries=0
 retryBackOffMs=500
diff --git a/gradlew b/gradlew
index b9bb139f790..249efbb032c 100755
--- a/gradlew
+++ b/gradlew
@@ -20,7 +20,7 @@
 
 ##############################################################################
 #
-#   Gradle start up script for POSIX generated by Gradle.
+#   gradlew start up script for POSIX generated by Gradle.
 #
 #   Important for running:
 #
@@ -29,7 +29,7 @@
 #       bash, then to run this script, type that shell name before the whole
 #       command line, like:
 #
-#           ksh Gradle
+#           ksh gradlew
 #
 #       Busybox and similar reduced shells will NOT work, because this script
 #       requires all of these POSIX shell features:
diff --git a/gradlew.bat b/gradlew.bat
index 24c62d56f2d..a51ec4f5886 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -19,7 +19,7 @@
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
-@rem  Gradle startup script for Windows
+@rem  gradlew startup script for Windows
 @rem
 @rem ##########################################################################
 
@@ -72,7 +72,7 @@ echo location of your Java installation. 1>&2
 
 
 
-@rem Execute Gradle
+@rem Execute gradlew
 @rem endlocal doesn't take effect until after the line is parsed and variables are expanded
 @rem which allows us to clear the local environment before executing the java command
 endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel

From 1b40080f664a4fe3b2b36a8faf6849902fcbc0ce Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Wed, 29 Jul 2026 16:35:22 +0200
Subject: [PATCH 340/391] fix(anr): Use Proguard ID from origination ANR
 process with ANR profie chunks (#5852)

Prior to this commit, we'd always (rightly) bind originating process Proguard IDs to ANR events, but we'd (wrongly) bind current Proguard ID to ANR profile chunks. Usually the originating Proguard ID == the current Proguard ID, and so the discrepancy didn't matter. But the two differ in the situation when a user updates the host app after the ANR occurs but before it's reported. When that happens, deobfuscation for ANR profile chunks in the Sentry UI can break.

This commit ensures both the ANR event and the ANR profile chunk receive the same originating Proguard ID by:

1. having the entity that determines the originating Proguard ID (ApplicationExitInfoEventProcessor) pass that ID to the profile chunk pipeline; and

2. updating our DebugMeta.buildDebugMeta(ProfileChunk, ...) method so that the profile chunk pipeline honors (rather than clobbers) the Proguard ID the event processor bakes into the DebugMeta owned by the incoming profile chunk.
---
 CHANGELOG.md                                  |   1 +
 .../ApplicationExitInfoEventProcessor.java    |  65 ++++++++--
 .../ApplicationExitInfoEventProcessorTest.kt  |  57 +++++++++
 .../java/io/sentry/protocol/DebugMeta.java    |  68 ++++++++--
 .../test/java/io/sentry/SentryClientTest.kt   |  63 +++++++++
 .../java/io/sentry/protocol/DebugMetaTest.kt  | 120 ++++++++++++++++++
 6 files changed, 353 insertions(+), 21 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a01233aebf9..9aaa10b3482 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,7 @@
 
 ### Fixes
 
+- Use the original app build's ProGuard UUID for ANR profile chunks ([#5852](https://github.com/getsentry/sentry-java/pull/5852))
 - Fix potential ANR/deadlock in Session Replay when `checkCanRecord` runs on the replay executor thread ([#5837](https://github.com/getsentry/sentry-java/pull/5837))
 - Prevent concurrent PixelCopy access during Session Replay masking and bitmap cleanup ([#5808](https://github.com/getsentry/sentry-java/pull/5808))
 - Release `MediaMuxer` when the replay video encoder fails to start to avoid a resource leak ([#5607](https://github.com/getsentry/sentry-java/pull/5607))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
index ee07736123b..3182828a024 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ApplicationExitInfoEventProcessor.java
@@ -184,7 +184,7 @@ public ApplicationExitInfoEventProcessor(
     setStaticValues(event);
 
     if (hintEnricher != null) {
-      hintEnricher.applyPostEnrichment(event, backfillable, unwrappedHint);
+      hintEnricher.applyPostEnrichment(event, backfillable, unwrappedHint, optionsSource);
     }
 
     return event;
@@ -504,10 +504,7 @@ private void setDebugMeta(
               PROGUARD_UUID_FILENAME, String.class, options.getProguardUuid(), optionsSource);
 
       if (proguardUuid != null) {
-        final DebugImage debugImage = new DebugImage();
-        debugImage.setType(DebugImage.PROGUARD);
-        debugImage.setUuid(proguardUuid);
-        images.add(debugImage);
+        images.add(createProguardDebugImage(proguardUuid));
       }
       event.setDebugMeta(debugMeta);
     }
@@ -790,7 +787,10 @@ void applyPreEnrichment(
         @NotNull SentryEvent event, @NotNull Backfillable hint, @NotNull Object rawHint);
 
     void applyPostEnrichment(
-        @NotNull SentryEvent event, @NotNull Backfillable hint, @NotNull Object rawHint);
+        @NotNull SentryEvent event,
+        @NotNull Backfillable hint,
+        @NotNull Object rawHint,
+        @NotNull OptionsSource optionsSource);
   }
 
   private final class AnrHintEnricher implements HintEnricher {
@@ -822,11 +822,14 @@ public void applyPreEnrichment(
 
     @Override
     public void applyPostEnrichment(
-        @NotNull SentryEvent event, @NotNull Backfillable hint, @NotNull Object rawHint) {
+        @NotNull SentryEvent event,
+        @NotNull Backfillable hint,
+        @NotNull Object rawHint,
+        @NotNull OptionsSource optionsSource) {
       final boolean isBackgroundAnr = isBackgroundAnr(rawHint);
 
       if (options.isAnrProfilingEnabled()) {
-        applyAnrProfile(event, hint, isBackgroundAnr);
+        applyAnrProfile(event, hint, isBackgroundAnr, optionsSource);
       }
 
       setDefaultAnrFingerprint(event, isBackgroundAnr);
@@ -920,7 +923,10 @@ private void setAnrExceptions(
     }
 
     private void applyAnrProfile(
-        @NotNull SentryEvent event, @NotNull Backfillable hint, boolean isBackgroundAnr) {
+        @NotNull SentryEvent event,
+        @NotNull Backfillable hint,
+        boolean isBackgroundAnr,
+        @NotNull OptionsSource optionsSource) {
 
       // Skip background ANRs (as profiling only runs in foreground)
       if (isBackgroundAnr) {
@@ -981,7 +987,8 @@ private void applyAnrProfile(
       }
 
       // Capture profile chunk
-      final @Nullable SentryId profilerId = captureAnrProfile(anrTimestamp, anrProfile);
+      final @Nullable SentryId profilerId =
+          captureAnrProfile(anrTimestamp, anrProfile, optionsSource);
       final @NotNull StackTraceElement[] stack = culprit.getStack();
 
       if (stack.length > 0) {
@@ -1012,7 +1019,10 @@ private void applyAnrProfile(
     }
 
     @Nullable
-    private SentryId captureAnrProfile(final long anrTimestampMs, @NotNull AnrProfile anrProfile) {
+    private SentryId captureAnrProfile(
+        final long anrTimestampMs,
+        @NotNull AnrProfile anrProfile,
+        final @NotNull OptionsSource optionsSource) {
       final SentryProfile profile = StackTraceConverter.convert(anrProfile);
       final ProfileChunk chunk =
           new ProfileChunk(
@@ -1024,6 +1034,7 @@ private SentryId captureAnrProfile(final long anrTimestampMs, @NotNull AnrProfil
               ProfileChunk.PLATFORM_ANDROID,
               options);
       chunk.setSentryProfile(profile);
+      chunk.setDebugMeta(createAnrProfileDebugMeta(optionsSource));
 
       final SentryId profilerId = Sentry.getCurrentScopes().captureProfileChunk(chunk);
       if (SentryId.EMPTY_ID.equals(profilerId)) {
@@ -1058,5 +1069,37 @@ private boolean hasOnlySystemFrames(@NotNull SentryEvent event) {
       }
       return true;
     }
+
+    /**
+     * Creates debug metadata for an ANR profile chunk using the build metadata selected for the ANR
+     * event.
+     *
+     * <p>ANR profile chunks are captured after app relaunch. If the app was updated between the ANR
+     * and the relaunch, the current options may contain the new build's ProGuard UUID. The provided
+     * {@link OptionsSource} lets us resolve the profile chunk and ANR event to the same originating
+     * build.
+     */
+    private @Nullable DebugMeta createAnrProfileDebugMeta(
+        final @NotNull OptionsSource optionsSource) {
+      final String proguardUuid =
+          getBuildOption(
+              PROGUARD_UUID_FILENAME, String.class, options.getProguardUuid(), optionsSource);
+      if (proguardUuid == null) {
+        // If no historical UUID is available, let the generic profile chunk pipeline apply the
+        // current options UUID as its normal best-effort fallback.
+        return null;
+      }
+
+      final DebugMeta debugMeta = new DebugMeta();
+      debugMeta.setImages(Collections.singletonList(createProguardDebugImage(proguardUuid)));
+      return debugMeta;
+    }
+  }
+
+  private static @NotNull DebugImage createProguardDebugImage(final @NotNull String proguardUuid) {
+    final DebugImage debugImage = new DebugImage();
+    debugImage.setType(DebugImage.PROGUARD);
+    debugImage.setUuid(proguardUuid);
+    return debugImage;
   }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
index d5b916d3b44..e80c738b5ea 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
@@ -11,6 +11,7 @@ import io.sentry.Hint
 import io.sentry.IScopes
 import io.sentry.IpAddressUtils
 import io.sentry.NoOpLogger
+import io.sentry.ProfileChunk
 import io.sentry.Sentry
 import io.sentry.SentryBaseEvent
 import io.sentry.SentryEvent
@@ -75,7 +76,9 @@ import org.junit.rules.TemporaryFolder
 import org.junit.runner.RunWith
 import org.mockito.Mockito.mockStatic
 import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 import org.robolectric.annotation.Config
 import org.robolectric.shadow.api.Shadow
@@ -1015,6 +1018,60 @@ class ApplicationExitInfoEventProcessorTest {
     }
   }
 
+  @Test
+  fun `uses persisted proguard uuid for ANR profile chunk after app update`() {
+    fixture.options.anrProfilingSampleRate = 1.0
+    fixture.options.proguardUuid = "current-uuid"
+    val processor =
+      fixture.getSut(
+        tmpDir,
+        populateScopeCache = false,
+        populateOptionsCache = false,
+        isSendDefaultPii = false,
+      )
+    fixture.persistOptions(PROGUARD_UUID_FILENAME, "previous-uuid")
+    setLastUpdateTime(2_000)
+
+    val hint =
+      HintUtils.createWithTypeCheckHint(
+        AbnormalExitHint(mechanism = "anr_foreground", timestamp = 1_000)
+      )
+
+    AnrProfileManager(
+        fixture.options,
+        AnrProfileRotationHelper.getFileForRecording(File(fixture.options.cacheDirPath!!)),
+      )
+      .apply {
+        add(
+          AnrStackTrace(
+            1_000,
+            arrayOf(
+              StackTraceElement("com.example.MyApp", "blocked", "MyApp.java", 42),
+              StackTraceElement("android.os.Handler", "dispatchMessage", "Handler.java", 5678),
+            ),
+          )
+        )
+        close()
+      }
+    AnrProfileRotationHelper.rotate()
+
+    val scopes = mock<IScopes>()
+    whenever(scopes.captureProfileChunk(any())).thenReturn(SentryId())
+
+    mockStatic(Sentry::class.java).use { mockedSentry ->
+      mockedSentry.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(scopes)
+
+      processor.process(SentryEvent(), hint)
+
+      val chunkCaptor = argumentCaptor<ProfileChunk>()
+      verify(scopes).captureProfileChunk(chunkCaptor.capture())
+      val images = chunkCaptor.firstValue.debugMeta!!.images!!
+      assertEquals(1, images.size)
+      assertEquals(DebugImage.PROGUARD, images[0].type)
+      assertEquals("previous-uuid", images[0].uuid)
+    }
+  }
+
   @Test
   fun `does not crash when ANR profiling is enabled but cache dir is null`() {
     fixture.options.anrProfilingSampleRate = 1.0
diff --git a/sentry/src/main/java/io/sentry/protocol/DebugMeta.java b/sentry/src/main/java/io/sentry/protocol/DebugMeta.java
index 45e5fda0603..9cfdb6f5f31 100644
--- a/sentry/src/main/java/io/sentry/protocol/DebugMeta.java
+++ b/sentry/src/main/java/io/sentry/protocol/DebugMeta.java
@@ -57,6 +57,19 @@ public void setSdkInfo(final @Nullable SdkInfo sdkInfo) {
   @ApiStatus.Internal
   public static @Nullable DebugMeta buildDebugMeta(
       final @Nullable DebugMeta eventDebugMeta, final @NotNull SentryOptions options) {
+    final @NotNull List<DebugImage> optionDebugImages = createDebugImagesFromOptions(options);
+
+    if (eventDebugMeta == null && optionDebugImages.isEmpty()) {
+      return null;
+    }
+
+    final @NotNull DebugMeta debugMeta = eventDebugMeta != null ? eventDebugMeta : new DebugMeta();
+    addMissingDebugImages(debugMeta, optionDebugImages);
+    return debugMeta;
+  }
+
+  private static @NotNull List<DebugImage> createDebugImagesFromOptions(
+      final @NotNull SentryOptions options) {
     final @NotNull List<DebugImage> debugImages = new ArrayList<>();
 
     if (options.getProguardUuid() != null) {
@@ -73,21 +86,56 @@ public void setSdkInfo(final @Nullable SdkInfo sdkInfo) {
       debugImages.add(sourceBundleImage);
     }
 
-    if (!debugImages.isEmpty()) {
-      DebugMeta debugMeta = eventDebugMeta;
+    return debugImages;
+  }
 
-      if (debugMeta == null) {
-        debugMeta = new DebugMeta();
+  private static void addMissingDebugImages(
+      final @NotNull DebugMeta debugMeta, final @NotNull List<DebugImage> candidates) {
+    if (candidates.isEmpty()) {
+      return;
+    }
+
+    if (debugMeta.getImages() == null) {
+      debugMeta.setImages(new ArrayList<>());
+    }
+
+    final @Nullable List<DebugImage> images = debugMeta.getImages();
+    if (images == null) {
+      return;
+    }
+
+    for (final @NotNull DebugImage candidate : candidates) {
+      if (isMissingDebugImage(images, candidate)) {
+        images.add(candidate);
       }
-      if (debugMeta.getImages() == null) {
-        debugMeta.setImages(debugImages);
-      } else {
-        debugMeta.getImages().addAll(debugImages);
+    }
+  }
+
+  private static boolean isMissingDebugImage(
+      final @NotNull List<DebugImage> images, final @NotNull DebugImage candidate) {
+    for (final @NotNull DebugImage image : images) {
+      if (isMatchingDebugImage(image, candidate)) {
+        return false;
       }
+    }
+    return true;
+  }
 
-      return debugMeta;
+  private static boolean isMatchingDebugImage(
+      final @NotNull DebugImage image, final @NotNull DebugImage candidate) {
+    // There can only be one ProGuard mapping per payload, so an existing ProGuard image takes
+    // precedence over the option-derived default.
+    if (DebugImage.PROGUARD.equals(candidate.getType())) {
+      return DebugImage.PROGUARD.equals(image.getType());
     }
-    return null;
+
+    if (DebugImage.JVM.equals(candidate.getType())) {
+      return DebugImage.JVM.equals(image.getType())
+          && candidate.getDebugId() != null
+          && candidate.getDebugId().equals(image.getDebugId());
+    }
+
+    return false;
   }
 
   // JsonKeys
diff --git a/sentry/src/test/java/io/sentry/SentryClientTest.kt b/sentry/src/test/java/io/sentry/SentryClientTest.kt
index fa37cb0b70b..02623556498 100644
--- a/sentry/src/test/java/io/sentry/SentryClientTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryClientTest.kt
@@ -18,6 +18,8 @@ import io.sentry.logger.ILoggerBatchProcessorFactory
 import io.sentry.metrics.IMetricsBatchProcessor
 import io.sentry.metrics.IMetricsBatchProcessorFactory
 import io.sentry.protocol.Contexts
+import io.sentry.protocol.DebugImage
+import io.sentry.protocol.DebugMeta
 import io.sentry.protocol.Feedback
 import io.sentry.protocol.Mechanism
 import io.sentry.protocol.Message
@@ -1993,6 +1995,56 @@ class SentryClientTest {
     verifyProfileChunkInEnvelope(fixture.profileChunk.chunkId)
   }
 
+  @Test
+  fun `captureProfileChunk adds options proguard debug meta`() {
+    fixture.sentryOptions.proguardUuid = "current-uuid"
+
+    val client = fixture.getSut()
+    client.captureProfileChunk(fixture.profileChunk, mock())
+
+    verify(fixture.transport)
+      .send(
+        check { actual ->
+          val profileChunk = getProfileChunkFromEnvelope(actual)
+          val images = profileChunk.debugMeta!!.images!!
+
+          assertEquals(1, images.size)
+          assertEquals(DebugImage.PROGUARD, images[0].type)
+          assertEquals("current-uuid", images[0].uuid)
+        }
+      )
+  }
+
+  @Test
+  fun `captureProfileChunk preserves existing proguard debug meta`() {
+    fixture.sentryOptions.proguardUuid = "current-uuid"
+    fixture.profileChunk.debugMeta =
+      DebugMeta().apply {
+        images =
+          listOf(
+            DebugImage().apply {
+              type = DebugImage.PROGUARD
+              uuid = "previous-uuid"
+            }
+          )
+      }
+
+    val client = fixture.getSut()
+    client.captureProfileChunk(fixture.profileChunk, mock())
+
+    verify(fixture.transport)
+      .send(
+        check { actual ->
+          val profileChunk = getProfileChunkFromEnvelope(actual)
+          val images = profileChunk.debugMeta!!.images!!
+
+          assertEquals(1, images.size)
+          assertEquals(DebugImage.PROGUARD, images[0].type)
+          assertEquals("previous-uuid", images[0].uuid)
+        }
+      )
+  }
+
   @Test
   fun `when captureProfileChunk with empty trace file, profile chunk is not sent`() {
     val client = fixture.getSut()
@@ -4169,6 +4221,17 @@ class SentryClientTest {
     )!!
   }
 
+  private fun getProfileChunkFromData(data: ByteArray): ProfileChunk {
+    val inputStream = InputStreamReader(ByteArrayInputStream(data))
+    return fixture.sentryOptions.serializer.deserialize(inputStream, ProfileChunk::class.java)!!
+  }
+
+  private fun getProfileChunkFromEnvelope(envelope: SentryEnvelope): ProfileChunk {
+    val profileChunkItem =
+      envelope.items.first { item -> item.header.type == SentryItemType.ProfileChunk }
+    return getProfileChunkFromData(profileChunkItem.data)
+  }
+
   private fun getReplayFromData(data: ByteArray): SentryReplayEvent? {
     val unpacker = MessagePack.newDefaultUnpacker(data)
     val mapSize = unpacker.unpackMapHeader()
diff --git a/sentry/src/test/java/io/sentry/protocol/DebugMetaTest.kt b/sentry/src/test/java/io/sentry/protocol/DebugMetaTest.kt
index 9cb8cf40946..a1c2f4edb05 100644
--- a/sentry/src/test/java/io/sentry/protocol/DebugMetaTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/DebugMetaTest.kt
@@ -57,6 +57,98 @@ class DebugMetaTest {
     }
   }
 
+  @Test
+  fun `when debug meta already has proguard image, does not attach options proguard uuid`() {
+    val options = SentryOptions().apply { proguardUuid = "current-id" }
+    val debugMeta =
+      DebugMeta.buildDebugMeta(
+        DebugMeta().apply {
+          images =
+            listOf(
+              DebugImage().apply {
+                type = DebugImage.PROGUARD
+                uuid = "existing-id"
+              }
+            )
+        },
+        options,
+      )
+
+    assertNotNull(debugMeta) {
+      assertNotNull(it.images) { images ->
+        assertEquals(1, images.size)
+        assertEquals("existing-id", images[0].uuid)
+        assertEquals(DebugImage.PROGUARD, images[0].type)
+      }
+    }
+  }
+
+  @Test
+  fun `when debug meta already has proguard image, still attaches missing bundle ids`() {
+    val options =
+      SentryOptions().apply {
+        proguardUuid = "current-id"
+        bundleIds.add("bundle-id")
+      }
+    val debugMeta =
+      DebugMeta.buildDebugMeta(
+        DebugMeta().apply {
+          images =
+            listOf(
+              DebugImage().apply {
+                type = DebugImage.PROGUARD
+                uuid = "existing-id"
+              }
+            )
+        },
+        options,
+      )
+
+    assertNotNull(debugMeta) {
+      assertNotNull(it.images) { images ->
+        assertEquals(2, images.size)
+        assertEquals(DebugImage.PROGUARD, images[0].type)
+        assertEquals("existing-id", images[0].uuid)
+        assertEquals(DebugImage.JVM, images[1].type)
+        assertEquals("bundle-id", images[1].debugId)
+      }
+    }
+  }
+
+  @Test
+  fun `when debug meta has unrelated debug image, attaches option debug information`() {
+    val options =
+      SentryOptions().apply {
+        proguardUuid = "proguard-id"
+        bundleIds.add("bundle-id")
+      }
+    val debugMeta =
+      DebugMeta.buildDebugMeta(
+        DebugMeta().apply {
+          images =
+            listOf(
+              DebugImage().apply {
+                type = "elf"
+                debugId = "native-id"
+              }
+            )
+        },
+        options,
+      )
+
+    assertNotNull(debugMeta) {
+      assertNotNull(it.images) { images ->
+        assertEquals(3, images.size)
+        assertEquals("elf", images[0].type)
+        assertEquals("native-id", images[0].debugId)
+        assertEquals(DebugImage.PROGUARD, images[1].type)
+        assertEquals("proguard-id", images[1].uuid)
+        assertEquals(DebugImage.JVM, images[2].type)
+        assertEquals("bundle-id", images[2].debugId)
+      }
+    }
+  }
+
   @Test
   fun `when event has debug meta and bundle ids are set, attaches debug information`() {
     val options = SentryOptions().apply { bundleIds.addAll(listOf("id1", "id2")) }
@@ -86,4 +178,32 @@ class DebugMetaTest {
       }
     }
   }
+
+  @Test
+  fun `when debug meta already has jvm image, only attaches missing bundle ids`() {
+    val options = SentryOptions().apply { bundleIds.addAll(listOf("id1", "id2")) }
+    val debugMeta =
+      DebugMeta.buildDebugMeta(
+        DebugMeta().apply {
+          images =
+            listOf(
+              DebugImage().apply {
+                type = DebugImage.JVM
+                debugId = "id1"
+              }
+            )
+        },
+        options,
+      )
+
+    assertNotNull(debugMeta) {
+      assertNotNull(it.images) { images ->
+        assertEquals(2, images.size)
+        assertEquals("id1", images[0].debugId)
+        assertEquals(DebugImage.JVM, images[0].type)
+        assertEquals("id2", images[1].debugId)
+        assertEquals(DebugImage.JVM, images[1].type)
+      }
+    }
+  }
 }

From 80c3e67a26874c5c5906dc0fe688d0399b553565 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 29 Jul 2026 17:54:19 +0200
Subject: [PATCH 341/391] build: Replace Gradle APIs removed in Gradle 10
 (#5864)

Gradle 9.6 deprecated four APIs our build scripts still used, all of
which either fail or are removed in Gradle 10:

- Project.getProperties, replaced with providers.gradleProperty
- Project objects as dependency notation, replaced with project(path)
- the 'val x by creating' configuration delegate, replaced with create()
- the 'val x by getting' source set delegate, replaced with getByName()

The remaining Gradle 10 warnings come from Detekt and AGP internals, not
from our scripts, so they can only be resolved by upgrading those.

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .../src/main/kotlin/io.sentry.javadoc.aggregate.gradle.kts | 6 ++----
 build-logic/src/main/kotlin/io.sentry.javadoc.gradle.kts   | 2 +-
 build.gradle.kts                                           | 2 +-
 buildSrc/src/main/java/Publication.kt                      | 7 +++++--
 sentry-compose/build.gradle.kts                            | 6 +++---
 5 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/build-logic/src/main/kotlin/io.sentry.javadoc.aggregate.gradle.kts b/build-logic/src/main/kotlin/io.sentry.javadoc.aggregate.gradle.kts
index e06cb677319..8fde556d751 100644
--- a/build-logic/src/main/kotlin/io.sentry.javadoc.aggregate.gradle.kts
+++ b/build-logic/src/main/kotlin/io.sentry.javadoc.aggregate.gradle.kts
@@ -1,11 +1,9 @@
 import io.sentry.gradle.AggregateJavadoc
 import org.gradle.api.attributes.Category
 import org.gradle.api.attributes.LibraryElements
-import org.gradle.kotlin.dsl.creating
-import org.gradle.kotlin.dsl.getValue
 import org.gradle.kotlin.dsl.named
 
-val javadocPublisher by configurations.creating {
+val javadocPublisher = configurations.create("javadocPublisher") {
     isCanBeConsumed = false
     isCanBeResolved = true
     attributes {
@@ -15,7 +13,7 @@ val javadocPublisher by configurations.creating {
 }
 
 subprojects {
-    javadocPublisher.dependencies.add(dependencies.create(this))
+    javadocPublisher.dependencies.add(rootProject.dependencies.project(path))
 }
 
 val javadocCollection = javadocPublisher.incoming.artifactView { lenient(true) }.files
diff --git a/build-logic/src/main/kotlin/io.sentry.javadoc.gradle.kts b/build-logic/src/main/kotlin/io.sentry.javadoc.gradle.kts
index 7eb796a02ff..21f81fec36a 100644
--- a/build-logic/src/main/kotlin/io.sentry.javadoc.gradle.kts
+++ b/build-logic/src/main/kotlin/io.sentry.javadoc.gradle.kts
@@ -1,4 +1,4 @@
-val javadocConfig: Configuration by configurations.creating {
+val javadocConfig: Configuration = configurations.create("javadocConfig") {
     isCanBeResolved = false
     isCanBeConsumed = true
 
diff --git a/build.gradle.kts b/build.gradle.kts
index 7d8cfcb626e..a663628b467 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -92,7 +92,7 @@ apiValidation {
 
 allprojects {
     group = Config.Sentry.group
-    version = properties[Config.Sentry.versionNameProp].toString()
+    version = providers.gradleProperty(Config.Sentry.versionNameProp).get()
     description = Config.Sentry.description
     tasks {
         withType<Test>().configureEach {
diff --git a/buildSrc/src/main/java/Publication.kt b/buildSrc/src/main/java/Publication.kt
index 0aa717a5630..d545e6e32dc 100644
--- a/buildSrc/src/main/java/Publication.kt
+++ b/buildSrc/src/main/java/Publication.kt
@@ -7,10 +7,13 @@ private object Consts {
     val taskRegex = Regex("(.*)DistZip")
 }
 
+private fun Project.versionName(): String =
+    providers.gradleProperty("versionName").get()
+
 // configure distZip tasks for multiplatform
 fun DistributionContainer.configureForMultiplatform(project: Project) {
     val sep = File.separator
-    val version = project.properties["versionName"].toString()
+    val version = project.versionName()
     val name = project.name
 
     this.maybeCreate("android").contents {
@@ -69,7 +72,7 @@ fun DistributionContainer.configureForMultiplatform(project: Project) {
 
 fun DistributionContainer.configureForJvm(project: Project) {
     val sep = File.separator
-    val version = project.properties["versionName"].toString()
+    val version = project.versionName()
     val name = project.name
 
     this.getByName("main").contents {
diff --git a/sentry-compose/build.gradle.kts b/sentry-compose/build.gradle.kts
index 4ebd9349662..8b835ba16fe 100644
--- a/sentry-compose/build.gradle.kts
+++ b/sentry-compose/build.gradle.kts
@@ -44,13 +44,13 @@ kotlin {
   }
 
   sourceSets {
-    val commonMain by getting {
+    getByName("commonMain") {
       compilerOptions {
         apiVersion.set(KotlinVersion.KOTLIN_1_9)
         languageVersion.set(KotlinVersion.KOTLIN_1_9)
       }
     }
-    val androidMain by getting {
+    getByName("androidMain") {
       dependencies {
         api(projects.sentry)
         api(projects.sentryAndroidNavigation)
@@ -60,7 +60,7 @@ kotlin {
         implementation(libs.androidx.lifecycle.common.java8)
       }
     }
-    val androidUnitTest by getting {
+    getByName("androidUnitTest") {
       dependencies {
         implementation(libs.androidx.compose.ui.test.junit4)
         implementation(libs.androidx.navigation.compose)

From 7055ed1d017c60459231faac78a2664c607467c5 Mon Sep 17 00:00:00 2001
From: Matthew Jay Williams <31186619+43jay@users.noreply.github.com>
Date: Wed, 29 Jul 2026 12:01:23 -0400
Subject: [PATCH 342/391] feat(profiling): Add Android ProfilingManager
 (Perfetto) support (#5251)

---
 CHANGELOG.md                                  |   9 +
 .../api/sentry-android-core.api               |  18 +
 .../core/AndroidContinuousProfiler.java       |   5 +
 .../core/AndroidOptionsInitializer.java       |  64 +-
 .../android/core/ManifestMetadataReader.java  |   5 +
 .../core/PerfettoContinuousProfiler.java      | 648 ++++++++++++++++++
 .../sentry/android/core/PerfettoProfiler.java | 237 +++++++
 .../core/SentryPerformanceProvider.java       |  17 +
 .../core/AndroidContinuousProfilerTest.kt     | 401 +++--------
 .../core/AndroidOptionsInitializerTest.kt     |  66 ++
 .../core/ChunkMeasurementCollectorTest.kt     | 146 ++++
 .../core/ContinuousProfilerTestCases.kt       | 194 ++++++
 .../core/ManifestMetadataReaderTest.kt        |  25 +
 .../core/PerfettoContinuousProfilerTest.kt    | 223 ++++++
 .../android/core/PerfettoProfilerTest.kt      | 268 ++++++++
 .../src/main/AndroidManifest.xml              |   5 +-
 .../samples/android/ProfilingActivity.kt      | 242 +++----
 .../samples/android/ProfilingListAdapter.kt   |  41 --
 .../main/res/layout/activity_profiling.xml    |  59 --
 .../main/res/layout/profiling_item_list.xml   |  15 -
 .../src/main/res/values/strings.xml           |  13 +-
 sentry/api/sentry.api                         |  11 +
 .../DefaultCompositePerformanceCollector.java |   6 +-
 .../src/main/java/io/sentry/ProfileChunk.java |  31 +-
 .../SentryAppStartProfilingOptions.java       |  19 +
 .../src/main/java/io/sentry/SentryClient.java |  13 +-
 .../java/io/sentry/SentryEnvelopeItem.java    |  74 ++
 .../io/sentry/SentryEnvelopeItemHeader.java   | 107 ++-
 .../main/java/io/sentry/SentryOptions.java    |  38 +
 .../test/java/io/sentry/JsonSerializerTest.kt |   3 +-
 .../java/io/sentry/SentryEnvelopeItemTest.kt  |  99 +++
 .../test/java/io/sentry/SentryOptionsTest.kt  |  11 +
 32 files changed, 2516 insertions(+), 597 deletions(-)
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
 create mode 100644 sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/ChunkMeasurementCollectorTest.kt
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/ContinuousProfilerTestCases.kt
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
 create mode 100644 sentry-android-core/src/test/java/io/sentry/android/core/PerfettoProfilerTest.kt
 delete mode 100644 sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingListAdapter.kt
 delete mode 100644 sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml
 delete mode 100644 sentry-samples/sentry-samples-android/src/main/res/layout/profiling_item_list.xml

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9aaa10b3482..d05335e9aa3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+### Features
+
+- Use Android's `ProfilingManager` (Perfetto) for continuous profiling on API 35+ devices ([#5251](https://github.com/getsentry/sentry-java/pull/5251))
+  - On API 35+ devices, continuous profiling now automatically uses Android's system `ProfilingManager` with Perfetto-based stack sampling, providing lower-overhead and more accurate profiles. No configuration change is required.
+  - Devices below API 35 keep using the legacy `Debug`-based profiler.
+  - Added an `enableLegacyProfiling` option (default `true`) to disable the legacy `Debug`-based profiler. Setting it to `false` disables continuous profiling on API < 35 devices as well as transaction-based profiling (`profilesSampleRate`/`profilesSampler`) on all devices, since transaction-based profiling is not supported by Perfetto. 
+  - It can also be configured via the `io.sentry.profiling.enable-legacy-profiling` manifest flag.
+  - See the [Android profiling docs](https://docs.sentry.io/platforms/android/profiling/) for details.
+
 ### Behavioral Changes
 
 - The outbox and cache directories are no longer created by `Sentry.init` ([#5792](https://github.com/getsentry/sentry-java/pull/5792))
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index adebedf2700..da80a74e32c 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -362,6 +362,24 @@ public final class io/sentry/android/core/NetworkBreadcrumbsIntegration : io/sen
 	public fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 
+public class io/sentry/android/core/PerfettoContinuousProfiler : io/sentry/IContinuousProfiler, io/sentry/transport/RateLimiter$IRateLimitObserver {
+	public fun <init> (Lio/sentry/ILogger;Lio/sentry/android/core/internal/util/SentryFrameMetricsCollector;Lio/sentry/util/LazyEvaluator$Evaluator;Ljava/util/function/Supplier;)V
+	public fun close (Z)V
+	public fun getChunkId ()Lio/sentry/protocol/SentryId;
+	public fun getProfilerId ()Lio/sentry/protocol/SentryId;
+	public fun isRunning ()Z
+	public fun onRateLimitChanged (Lio/sentry/transport/RateLimiter;)V
+	public fun reevaluateSampling ()V
+	public fun startProfiler (Lio/sentry/ProfileLifecycle;Lio/sentry/TracesSampler;)V
+	public fun stopProfiler (Lio/sentry/ProfileLifecycle;)V
+}
+
+public class io/sentry/android/core/PerfettoProfiler {
+	public fun <init> (Landroid/content/Context;Lio/sentry/ILogger;Lio/sentry/ISentryExecutorService;)V
+	public fun endAndCollect (Ljava/util/function/Consumer;)V
+	public fun start (J)Z
+}
+
 public final class io/sentry/android/core/ScreenshotEventProcessor : io/sentry/EventProcessor {
 	public fun <init> (Lio/sentry/android/core/SentryAndroidOptions;Lio/sentry/android/core/BuildInfoProvider;Z)V
 	public fun getOrder ()Ljava/lang/Long;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
index 41362c9d93e..a1c0c097cb9 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java
@@ -38,6 +38,11 @@
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.VisibleForTesting;
 
+/**
+ * Legacy Android implementation of {@link IContinuousProfiler}, using Android's {@code
+ * Debug.startMethodTracingSampling} See {@link PerfettoContinuousProfiler} for the new
+ * implementation using {@code ProfilingManager}, available on API 35+.
+ */
 @ApiStatus.Internal
 public class AndroidContinuousProfiler
     implements IContinuousProfiler, RateLimiter.IRateLimitObserver {
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
index 434dfc73d3e..a0547a78b34 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java
@@ -2,6 +2,7 @@
 
 import static io.sentry.android.core.NdkIntegration.SENTRY_NDK_CLASS_NAME;
 
+import android.annotation.SuppressLint;
 import android.app.Application;
 import android.content.Context;
 import android.content.pm.PackageInfo;
@@ -299,6 +300,7 @@ static void initializeIntegrationsAndProcessors(
   }
 
   /** Setup the correct profiler (transaction or continuous) based on the options. */
+  @SuppressLint("NewApi")
   private static void setupProfiler(
       final @NotNull SentryAndroidOptions options,
       final @NotNull Context context,
@@ -308,6 +310,28 @@ private static void setupProfiler(
       final @NotNull CompositePerformanceCollector performanceCollector) {
     if (options.isProfilingEnabled() || options.getProfilesSampleRate() != null) {
       options.setContinuousProfiler(NoOpContinuousProfiler.getInstance());
+      // Transaction-based profiling always relies on the legacy Debug-based profiler, so it is
+      // disabled together with legacy profiling. Perfetto profiling only supports continuous
+      // profiling.
+      if (!options.isEnableLegacyProfiling()) {
+        options
+            .getLogger()
+            .log(
+                SentryLevel.WARNING,
+                "Transaction-based profiling (profilesSampleRate/profilesSampler) is disabled "
+                    + "because enableLegacyProfiling is false. Transaction-based profiling always "
+                    + "uses the legacy profiler and is not supported by Perfetto. No profiling "
+                    + "data will be collected. Use profileSessionSampleRate for continuous "
+                    + "profiling instead.");
+        options.setTransactionProfiler(NoOpTransactionProfiler.getInstance());
+        if (appStartTransactionProfiler != null) {
+          appStartTransactionProfiler.close();
+        }
+        if (appStartContinuousProfiler != null) {
+          appStartContinuousProfiler.close(true);
+        }
+        return;
+      }
       // This is a safeguard, but it should never happen, as the app start profiler should be the
       // continuous one.
       if (appStartContinuousProfiler != null) {
@@ -341,16 +365,36 @@ private static void setupProfiler(
           performanceCollector.start(chunkId.toString());
         }
       } else {
-        options.setContinuousProfiler(
-            new AndroidContinuousProfiler(
-                buildInfoProvider,
-                Objects.requireNonNull(
-                    options.getFrameMetricsCollector(),
-                    "options.getFrameMetricsCollector is required"),
-                options.getLogger(),
-                options.getProfilingTracesDirPath(),
-                options.getProfilingTracesHz(),
-                () -> options.getExecutorService()));
+        final @NotNull SentryFrameMetricsCollector frameMetricsCollector =
+            Objects.requireNonNull(
+                options.getFrameMetricsCollector(), "options.getFrameMetricsCollector is required");
+        if (buildInfoProvider.getSdkInfoVersion() >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+          final @NotNull Context appContext = ContextUtils.getApplicationContext(context);
+          options.setContinuousProfiler(
+              new PerfettoContinuousProfiler(
+                  options.getLogger(),
+                  frameMetricsCollector,
+                  () -> options.getExecutorService(),
+                  () ->
+                      new PerfettoProfiler(
+                          appContext, options.getLogger(), options.getExecutorService())));
+        } else if (options.isEnableLegacyProfiling()) {
+          options.setContinuousProfiler(
+              new AndroidContinuousProfiler(
+                  buildInfoProvider,
+                  frameMetricsCollector,
+                  options.getLogger(),
+                  options.getProfilingTracesDirPath(),
+                  options.getProfilingTracesHz(),
+                  () -> options.getExecutorService()));
+        } else {
+          options
+              .getLogger()
+              .log(
+                  SentryLevel.WARNING,
+                  "enableLegacyProfiling is disabled and device is below API 35. "
+                      + "No profiling data will be collected.");
+        }
       }
     }
   }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
index 469f15e3f3b..f21d4c801a3 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java
@@ -119,6 +119,8 @@ final class ManifestMetadataReader {
 
   static final String ENABLE_APP_START_PROFILING = "io.sentry.profiling.enable-app-start";
 
+  static final String ENABLE_LEGACY_PROFILING = "io.sentry.profiling.enable-legacy-profiling";
+
   static final String ENABLE_SCOPE_PERSISTENCE = "io.sentry.enable-scope-persistence";
 
   static final String REPLAYS_SESSION_SAMPLE_RATE = "io.sentry.session-replay.session-sample-rate";
@@ -542,6 +544,9 @@ static void applyMetadata(
             readBool(
                 metadata, logger, ENABLE_APP_START_PROFILING, options.isEnableAppStartProfiling()));
 
+        options.setEnableLegacyProfiling(
+            readBool(metadata, logger, ENABLE_LEGACY_PROFILING, options.isEnableLegacyProfiling()));
+
         options.setEnableScopePersistence(
             readBool(
                 metadata, logger, ENABLE_SCOPE_PERSISTENCE, options.isEnableScopePersistence()));
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
new file mode 100644
index 00000000000..d4260e93dd7
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
@@ -0,0 +1,648 @@
+package io.sentry.android.core;
+
+import static io.sentry.DataCategory.All;
+import static io.sentry.IConnectionStatusProvider.ConnectionStatus.DISCONNECTED;
+
+import android.os.Build;
+import android.os.SystemClock;
+import androidx.annotation.RequiresApi;
+import io.sentry.CompositePerformanceCollector;
+import io.sentry.DataCategory;
+import io.sentry.IContinuousProfiler;
+import io.sentry.ILogger;
+import io.sentry.IScopes;
+import io.sentry.ISentryExecutorService;
+import io.sentry.ISentryLifecycleToken;
+import io.sentry.NoOpScopes;
+import io.sentry.PerformanceCollectionData;
+import io.sentry.ProfileChunk;
+import io.sentry.ProfileLifecycle;
+import io.sentry.Sentry;
+import io.sentry.SentryDate;
+import io.sentry.SentryLevel;
+import io.sentry.SentryNanotimeDate;
+import io.sentry.SentryOptions;
+import io.sentry.TracesSampler;
+import io.sentry.android.core.internal.util.SentryFrameMetricsCollector;
+import io.sentry.profilemeasurements.ProfileMeasurement;
+import io.sentry.profilemeasurements.ProfileMeasurementValue;
+import io.sentry.protocol.SentryId;
+import io.sentry.transport.RateLimiter;
+import io.sentry.util.AutoClosableReentrantLock;
+import io.sentry.util.LazyEvaluator;
+import io.sentry.util.SentryRandom;
+import java.io.File;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentLinkedDeque;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.VisibleForTesting;
+
+/**
+ * Continuous profiler that uses Android's {@link android.os.ProfilingManager} (API 35+) to capture
+ * Perfetto stack-sampling traces.
+ *
+ * <p>This class is intentionally separate from {@link AndroidContinuousProfiler} to keep the two
+ * profiling backends independent. All ProfilingManager API usage is confined to this file and
+ * {@link PerfettoProfiler}.
+ *
+ * <p>Currently, this class doesn't do app-start profiling {@link SentryPerformanceProvider}. It is
+ * created during {@code Sentry.init()}.
+ *
+ * <p>Thread safety: all mutable state is guarded by a single {@link
+ * io.sentry.util.AutoClosableReentrantLock}. Public entry points ({@link #startProfiler}, {@link
+ * #stopProfiler}, {@link #close}, {@link #onRateLimitChanged}, {@link #reevaluateSampling}, and the
+ * getters) acquire the lock themselves and are thread-safe. Private methods {@code startInternal}
+ * and {@code stopInternal} require the caller to hold the lock.
+ */
+@ApiStatus.Internal
+@RequiresApi(api = Build.VERSION_CODES.VANILLA_ICE_CREAM)
+public class PerfettoContinuousProfiler
+    implements IContinuousProfiler, RateLimiter.IRateLimitObserver {
+  private static final long MAX_CHUNK_DURATION_MILLIS = 60000;
+
+  // Matches the thread name produced by SentryExecutorService's thread factory, used to detect
+  // when we are already running on the executor thread.
+  private static final String EXECUTOR_THREAD_NAME_PREFIX = "SentryExecutorServiceThreadFactory";
+
+  private final @NotNull ILogger logger;
+  private final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier;
+  private final @NotNull Supplier<PerfettoProfiler> perfettoProfilerFactory;
+
+  private @Nullable PerfettoProfiler perfettoProfiler = null;
+  private final @NotNull ChunkMeasurementCollector chunkMeasurements;
+  private boolean isRunning = false;
+  private @Nullable IScopes scopes;
+  private @Nullable CompositePerformanceCollector performanceCollector;
+  private @Nullable Future<?> stopFuture;
+  private @NotNull SentryId profilerId = SentryId.EMPTY_ID;
+  private @NotNull SentryId chunkId = SentryId.EMPTY_ID;
+  private final @NotNull AtomicBoolean isClosed = new AtomicBoolean(false);
+  private @NotNull SentryDate startProfileChunkTimestamp = new io.sentry.SentryNanotimeDate();
+  private boolean shouldSample = true;
+  private boolean shouldStop = false;
+  private boolean isSampled = false;
+  private int activeTraceCount = 0;
+
+  private final AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
+
+  public PerfettoContinuousProfiler(
+      final @NotNull ILogger logger,
+      final @NotNull SentryFrameMetricsCollector frameMetricsCollector,
+      final @NotNull LazyEvaluator.Evaluator<ISentryExecutorService> executorServiceSupplier,
+      final @NotNull Supplier<PerfettoProfiler> perfettoProfilerFactory) {
+    this.logger = logger;
+    this.chunkMeasurements = new ChunkMeasurementCollector(frameMetricsCollector);
+    this.executorServiceSupplier = executorServiceSupplier;
+    this.perfettoProfilerFactory = perfettoProfilerFactory;
+  }
+
+  @Override
+  public void startProfiler(
+      final @NotNull ProfileLifecycle profileLifecycle,
+      final @NotNull TracesSampler tracesSampler) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      if (shouldSample) {
+        isSampled = tracesSampler.sampleSessionProfile(SentryRandom.current().nextDouble());
+        shouldSample = false;
+      }
+      if (!isSampled) {
+        logger.log(SentryLevel.DEBUG, "Profiler was not started due to sampling decision.");
+        return;
+      }
+      switch (profileLifecycle) {
+        case TRACE:
+          activeTraceCount = Math.max(0, activeTraceCount); // safety check.
+          activeTraceCount++;
+          break;
+        case MANUAL:
+          if (isRunning()) {
+            logger.log(
+                SentryLevel.WARNING,
+                "Unexpected call to startProfiler(MANUAL) while profiler already running. Skipping.");
+            return;
+          }
+          break;
+      }
+      if (!isRunning()) {
+        logger.log(SentryLevel.DEBUG, "Started Profiler.");
+        shouldStop = false;
+        startInternal();
+      }
+    }
+  }
+
+  @Override
+  public void stopProfiler(final @NotNull ProfileLifecycle profileLifecycle) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      switch (profileLifecycle) {
+        case TRACE:
+          activeTraceCount--;
+          activeTraceCount = Math.max(0, activeTraceCount); // safety check
+          // If there are active spans, and profile lifecycle is trace, we don't stop the profiler
+          if (activeTraceCount > 0) {
+            return;
+          }
+          shouldStop = true;
+          break;
+        case MANUAL:
+          shouldStop = true;
+          break;
+      }
+    }
+  }
+
+  /**
+   * Stop the profiler as soon as we are rate limited, to avoid the performance overhead.
+   *
+   * @param rateLimiter the {@link RateLimiter} instance to check categories against
+   */
+  @Override
+  public void onRateLimitChanged(@NotNull RateLimiter rateLimiter) {
+    if (rateLimiter.isActiveForCategory(All)
+        || rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi)) {
+      try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+        logger.log(SentryLevel.WARNING, "SDK is rate limited. Stopping profiler.");
+        stopInternal(false);
+      }
+    }
+    // If we are not rate limited anymore, we don't do anything: the profile is broken, so it's
+    // useless to restart it automatically
+  }
+
+  @Override
+  public void close(final boolean isTerminating) {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      activeTraceCount = 0;
+      shouldStop = true;
+      if (isTerminating) {
+        stopInternal(false);
+        isClosed.set(true);
+      }
+    }
+  }
+
+  @Override
+  public @NotNull SentryId getProfilerId() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return profilerId;
+    }
+  }
+
+  @Override
+  public @NotNull SentryId getChunkId() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return chunkId;
+    }
+  }
+
+  @Override
+  public boolean isRunning() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      return isRunning;
+    }
+  }
+
+  /**
+   * Resolves scopes on first call. Since PerfettoContinuousProfiler is created during Sentry.init()
+   * and never used for app-start profiling, scopes is guaranteed to be available by the time
+   * startProfiler is called.
+   *
+   * <p>Caller must hold {@link #lock}.
+   */
+  private @NotNull IScopes resolveScopes() {
+    if (scopes != null && scopes != NoOpScopes.getInstance()) {
+      return scopes;
+    }
+    final @NotNull IScopes currentScopes = Sentry.getCurrentScopes();
+    if (currentScopes == NoOpScopes.getInstance()) {
+      logger.log(
+          SentryLevel.ERROR,
+          "PerfettoContinuousProfiler: scopes not available. This is unexpected.");
+      return currentScopes;
+    }
+    this.scopes = currentScopes;
+    this.performanceCollector = currentScopes.getOptions().getCompositePerformanceCollector();
+    final @Nullable RateLimiter rateLimiter = currentScopes.getRateLimiter();
+    if (rateLimiter != null) {
+      rateLimiter.addRateLimitObserver(this);
+    }
+    return scopes;
+  }
+
+  /** Caller must hold {@link #lock}. */
+  private void startInternal() {
+    final @NotNull IScopes scopes = resolveScopes();
+
+    final @Nullable RateLimiter rateLimiter = scopes.getRateLimiter();
+    if (rateLimiter != null
+        && (rateLimiter.isActiveForCategory(All)
+            || rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi))) {
+      logger.log(SentryLevel.WARNING, "SDK is rate limited. Stopping profiler.");
+      stopInternal(false);
+      return;
+    }
+
+    // If device is offline, we don't start the profiler, to avoid flooding the cache
+    if (scopes.getOptions().getConnectionStatusProvider().getConnectionStatus() == DISCONNECTED) {
+      logger.log(SentryLevel.WARNING, "Device is offline. Stopping profiler.");
+      stopInternal(false);
+      return;
+    }
+    startProfileChunkTimestamp = scopes.getOptions().getDateProvider().now();
+
+    perfettoProfiler = perfettoProfilerFactory.get();
+    if (perfettoProfiler == null) {
+      return;
+    }
+    if (!perfettoProfiler.start(MAX_CHUNK_DURATION_MILLIS)) {
+      logger.log(
+          SentryLevel.ERROR,
+          "Failed to start Perfetto profiling. PerfettoProfiler.start() returned false.");
+      return;
+    }
+
+    isRunning = true;
+
+    if (profilerId.equals(SentryId.EMPTY_ID)) {
+      profilerId = new SentryId();
+    }
+
+    if (chunkId.equals(SentryId.EMPTY_ID)) {
+      chunkId = new SentryId();
+    }
+
+    chunkMeasurements.start(performanceCollector, chunkId.toString());
+
+    try {
+      stopFuture =
+          executorServiceSupplier
+              .evaluate()
+              .schedule(
+                  () -> {
+                    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+                      stopInternal(true);
+                    }
+                  },
+                  MAX_CHUNK_DURATION_MILLIS);
+    } catch (RejectedExecutionException e) {
+      logger.log(
+          SentryLevel.ERROR,
+          "Failed to schedule profiling chunk finish. Did you call Sentry.close()?",
+          e);
+      shouldStop = true;
+    }
+  }
+
+  /** Caller must hold {@link #lock}. */
+  private void stopInternal(final boolean restartProfiler) {
+    final @Nullable PerfettoProfiler currentProfiler = perfettoProfiler;
+
+    if (stopFuture != null) {
+      stopFuture.cancel(false);
+    }
+
+    // Make sure perfetto was running
+    if (currentProfiler == null || !isRunning) {
+      profilerId = SentryId.EMPTY_ID;
+      chunkId = SentryId.EMPTY_ID;
+      return;
+    }
+
+    final @NotNull IScopes scopes = resolveScopes();
+    final @NotNull SentryOptions options = scopes.getOptions();
+
+    final @NotNull Map<String, ProfileMeasurement> measurements = chunkMeasurements.stop();
+
+    // Capture state needed by the callback before clearing it
+    final @NotNull SentryId chunkProfilerId = profilerId;
+    final @NotNull SentryId chunkChunkId = chunkId;
+    final @NotNull SentryDate chunkTimestamp = startProfileChunkTimestamp;
+
+    isRunning = false;
+    perfettoProfiler = null;
+    chunkId = SentryId.EMPTY_ID;
+
+    if (!restartProfiler || shouldStop) {
+      profilerId = SentryId.EMPTY_ID;
+    }
+
+    final boolean shouldRestart = restartProfiler && !shouldStop;
+
+    // endAndCollect is non-blocking: the listener fires when the OS delivers the trace file.
+    // Synchronous: result already available — callback runs inline, lock is still held (re-entrant)
+    // Asynchronous: callback runs on an OS thread — acquires lock itself for restart
+    currentProfiler.endAndCollect(
+        traceFile ->
+            onChunkCollected(
+                traceFile,
+                chunkProfilerId,
+                chunkChunkId,
+                measurements,
+                chunkTimestamp,
+                shouldRestart,
+                scopes,
+                options));
+  }
+
+  private void onChunkCollected(
+      final @Nullable File traceFile,
+      final @NotNull SentryId chunkProfilerId,
+      final @NotNull SentryId chunkChunkId,
+      final @NotNull Map<String, ProfileMeasurement> measurements,
+      final @NotNull SentryDate chunkTimestamp,
+      final boolean shouldRestart,
+      final @NotNull IScopes scopes,
+      final @NotNull SentryOptions options) {
+    if (traceFile == null) {
+      logger.log(
+          SentryLevel.ERROR,
+          "An error occurred while collecting a profile chunk, and it won't be sent.");
+    } else {
+      final ProfileChunk.Builder builder =
+          new ProfileChunk.Builder(
+              chunkProfilerId,
+              chunkChunkId,
+              measurements,
+              traceFile,
+              chunkTimestamp,
+              ProfileChunk.PLATFORM_ANDROID);
+      builder.setContentType(ProfileChunk.CONTENT_TYPE_PERFETTO);
+      sendChunk(builder, scopes, options);
+    }
+
+    if (shouldRestart) {
+      try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+        // shouldStop is re-checked here (not just at capture time) because a stopProfiler() or
+        // close() may have been requested while this async callback was pending.
+        if (isRunning || isClosed.get() || shouldStop) {
+          logger.log(
+              SentryLevel.DEBUG,
+              "Profile chunk finished, but profiler was already restarted, closed or stopped. Skipping.");
+          return;
+        }
+        logger.log(SentryLevel.DEBUG, "Profile chunk finished. Starting a new one.");
+        startInternal();
+      }
+    } else {
+      logger.log(SentryLevel.DEBUG, "Profile chunk finished.");
+    }
+  }
+
+  public void reevaluateSampling() {
+    try (final @NotNull ISentryLifecycleToken ignored = lock.acquire()) {
+      shouldSample = true;
+    }
+  }
+
+  private void sendChunk(
+      final @NotNull ProfileChunk.Builder builder,
+      final @NotNull IScopes scopes,
+      final @NotNull SentryOptions options) {
+    final @NotNull Runnable task =
+        () -> {
+          if (isClosed.get()) {
+            return;
+          }
+          scopes.captureProfileChunk(builder.build(options));
+        };
+    try {
+      // The chunk timer callback (stopInternal) already runs on the executor thread; submitting
+      // back into the same single-threaded executor from there can deadlock, so run inline instead.
+      if (Thread.currentThread().getName().startsWith(EXECUTOR_THREAD_NAME_PREFIX)) {
+        task.run();
+      } else {
+        executorServiceSupplier.evaluate().submit(task);
+      }
+    } catch (Throwable e) {
+      options.getLogger().log(SentryLevel.DEBUG, "Failed to send profile chunk.", e);
+    }
+  }
+
+  /**
+   * Collects measurements for a single profiling chunk: frame metrics (slow/frozen frames, refresh
+   * rate) and performance data (CPU usage, memory footprint).
+   *
+   * <p>Frame metrics are delivered on the FrameMetrics HandlerThread. The deques use {@link
+   * ConcurrentLinkedDeque} because the HandlerThread writes and the executor thread reads.
+   *
+   * <p>Performance data is collected by the {@link CompositePerformanceCollector}'s Timer thread
+   * every 100ms and returned as a list on {@code stop()}.
+   */
+  @VisibleForTesting
+  static class ChunkMeasurementCollector {
+    private final @NotNull SentryFrameMetricsCollector frameMetricsCollector;
+    private @Nullable String frameMetricsListenerId = null;
+    private @Nullable CompositePerformanceCollector performanceCollector = null;
+    private @Nullable String chunkId = null;
+
+    private final @NotNull ConcurrentLinkedDeque<ProfileMeasurementValue>
+        slowFrameRenderMeasurements = new ConcurrentLinkedDeque<>();
+    private final @NotNull ConcurrentLinkedDeque<ProfileMeasurementValue>
+        frozenFrameRenderMeasurements = new ConcurrentLinkedDeque<>();
+    private final @NotNull ConcurrentLinkedDeque<ProfileMeasurementValue>
+        screenFrameRateMeasurements = new ConcurrentLinkedDeque<>();
+
+    // Elapsed realtime when the measurement was started (nanosecond precision).
+    // Used to convert wall-time clock values into ns-since-chunk-start for the measurements
+    // payload.
+    private long profileStartElapsedRealtimeNanos = 0;
+
+    ChunkMeasurementCollector(final @NotNull SentryFrameMetricsCollector frameMetricsCollector) {
+      this.frameMetricsCollector = frameMetricsCollector;
+    }
+
+    void start(
+        final @Nullable CompositePerformanceCollector performanceCollector,
+        final @NotNull String chunkId) {
+      this.performanceCollector = performanceCollector;
+      this.chunkId = chunkId;
+      this.profileStartElapsedRealtimeNanos = SystemClock.elapsedRealtimeNanos();
+
+      // Start frame metrics collection (runs on the FrameMetrics HandlerThread)
+      slowFrameRenderMeasurements.clear();
+      frozenFrameRenderMeasurements.clear();
+      screenFrameRateMeasurements.clear();
+      frameMetricsListenerId =
+          frameMetricsCollector.startCollection(
+              new SentryFrameMetricsCollector.FrameMetricsCollectorListener() {
+                float lastRefreshRate = 0;
+
+                @Override
+                public void onFrameMetricCollected(
+                    final long frameStartNanos,
+                    final long frameEndNanos,
+                    final long durationNanos,
+                    final long delayNanos,
+                    final boolean isSlow,
+                    final boolean isFrozen,
+                    final float refreshRate) {
+                  final long timestampNanos = new SentryNanotimeDate().nanoTimestamp();
+                  // Convert frameEndNanos (reported by FrameMetricsCollector using System.nanoTime
+                  // /
+                  // SystemClock.uptimeMillis), into the SystemClock.elapsedRealtime to report
+                  // elapsed
+                  // realtime nanos since chunk start
+                  final long frameEndElapsedRealtimeNanos =
+                      frameEndNanos - System.nanoTime() + SystemClock.elapsedRealtimeNanos();
+                  final long frameTimestampRelativeNanos =
+                      frameEndElapsedRealtimeNanos - profileStartElapsedRealtimeNanos;
+
+                  // We don't allow negative relative timestamps, e.g. for a frame that started
+                  // before the chunk did. This should never happen, but we check anyway.
+                  if (frameTimestampRelativeNanos < 0) {
+                    return;
+                  }
+                  if (isFrozen) {
+                    frozenFrameRenderMeasurements.addLast(
+                        new ProfileMeasurementValue(
+                            frameTimestampRelativeNanos, durationNanos, timestampNanos));
+                  } else if (isSlow) {
+                    slowFrameRenderMeasurements.addLast(
+                        new ProfileMeasurementValue(
+                            frameTimestampRelativeNanos, durationNanos, timestampNanos));
+                  }
+                  if (refreshRate != lastRefreshRate) {
+                    lastRefreshRate = refreshRate;
+                    screenFrameRateMeasurements.addLast(
+                        new ProfileMeasurementValue(
+                            frameTimestampRelativeNanos, refreshRate, timestampNanos));
+                  }
+                }
+              });
+
+      // Start performance collection (runs on CompositePerformanceCollector's Timer thread)
+      if (performanceCollector != null) {
+        performanceCollector.start(chunkId);
+      }
+    }
+
+    /**
+     * Stops all collection, builds and returns the combined measurements map containing frame
+     * metrics and performance data (CPU, memory).
+     */
+    @NotNull
+    Map<String, ProfileMeasurement> stop() {
+      final @NotNull Map<String, ProfileMeasurement> measurements = new HashMap<>();
+      // Stop frame metrics
+      frameMetricsCollector.stopCollection(frameMetricsListenerId);
+      frameMetricsListenerId = null;
+      addFrameDataToMeasurements(measurements);
+
+      // Stop performance collection
+      @Nullable List<PerformanceCollectionData> performanceData = null;
+      if (performanceCollector != null && chunkId != null) {
+        performanceData = performanceCollector.stop(chunkId);
+        final long wallClockNowNanos = TimeUnit.MILLISECONDS.toNanos(System.currentTimeMillis());
+        final long elapsedRealtimeNowNanos = SystemClock.elapsedRealtimeNanos();
+        addPerformanceDataToMeasurements(
+            performanceData,
+            measurements,
+            wallClockNowNanos,
+            elapsedRealtimeNowNanos,
+            profileStartElapsedRealtimeNanos);
+      }
+      performanceCollector = null;
+      chunkId = null;
+
+      return measurements;
+    }
+
+    private void addFrameDataToMeasurements(
+        final @NotNull Map<String, ProfileMeasurement> measurements) {
+      if (!slowFrameRenderMeasurements.isEmpty()) {
+        measurements.put(
+            ProfileMeasurement.ID_SLOW_FRAME_RENDERS,
+            new ProfileMeasurement(
+                ProfileMeasurement.UNIT_NANOSECONDS, new ArrayList<>(slowFrameRenderMeasurements)));
+      }
+      if (!frozenFrameRenderMeasurements.isEmpty()) {
+        measurements.put(
+            ProfileMeasurement.ID_FROZEN_FRAME_RENDERS,
+            new ProfileMeasurement(
+                ProfileMeasurement.UNIT_NANOSECONDS,
+                new ArrayList<>(frozenFrameRenderMeasurements)));
+      }
+      if (!screenFrameRateMeasurements.isEmpty()) {
+        measurements.put(
+            ProfileMeasurement.ID_SCREEN_FRAME_RATES,
+            new ProfileMeasurement(
+                ProfileMeasurement.UNIT_HZ, new ArrayList<>(screenFrameRateMeasurements)));
+      }
+    }
+
+    private static void addPerformanceDataToMeasurements(
+        final @Nullable List<PerformanceCollectionData> performanceData,
+        final @NotNull Map<String, ProfileMeasurement> measurements,
+        final long wallClockNowNanos,
+        final long elapsedRealtimeNowNanos,
+        final long profileStartElapsedRealtimeNanos) {
+      if (performanceData == null || performanceData.isEmpty()) {
+        return;
+      }
+      final @NotNull ArrayDeque<ProfileMeasurementValue> cpuUsageMeasurements =
+          new ArrayDeque<>(performanceData.size());
+      final @NotNull ArrayDeque<ProfileMeasurementValue> memoryUsageMeasurements =
+          new ArrayDeque<>(performanceData.size());
+      final @NotNull ArrayDeque<ProfileMeasurementValue> nativeMemoryUsageMeasurements =
+          new ArrayDeque<>(performanceData.size());
+
+      // CompositePerformanceCollector.stop() hands back its live list, which its timer thread may
+      // still write to, so we synchronize on it while iterating, as AndroidProfiler does.
+      synchronized (performanceData) {
+        for (final @NotNull PerformanceCollectionData data : performanceData) {
+          // Convert sample timestamps (reported by CompositePerformanceCollector using
+          // System.currentTimeMillis), into the SystemClock.elapsedRealtime to report
+          // elapsed realtime nanos since chunk start
+          final long nanoTimestamp = data.getNanoTimestamp();
+          final long nanosSinceSample = wallClockNowNanos - nanoTimestamp;
+          final long sampleElapsedRealtimeNanos = elapsedRealtimeNowNanos - nanosSinceSample;
+          final long relativeStartNs =
+              sampleElapsedRealtimeNanos - profileStartElapsedRealtimeNanos;
+          final @Nullable Double cpuUsagePercentage = data.getCpuUsagePercentage();
+          final @Nullable Long usedHeapMemory = data.getUsedHeapMemory();
+          final @Nullable Long usedNativeMemory = data.getUsedNativeMemory();
+
+          if (cpuUsagePercentage != null) {
+            cpuUsageMeasurements.addLast(
+                new ProfileMeasurementValue(relativeStartNs, cpuUsagePercentage, nanoTimestamp));
+          }
+          if (usedHeapMemory != null) {
+            memoryUsageMeasurements.addLast(
+                new ProfileMeasurementValue(relativeStartNs, usedHeapMemory, nanoTimestamp));
+          }
+          if (usedNativeMemory != null) {
+            nativeMemoryUsageMeasurements.addLast(
+                new ProfileMeasurementValue(relativeStartNs, usedNativeMemory, nanoTimestamp));
+          }
+        }
+      }
+
+      if (!cpuUsageMeasurements.isEmpty()) {
+        measurements.put(
+            ProfileMeasurement.ID_CPU_USAGE,
+            new ProfileMeasurement(ProfileMeasurement.UNIT_PERCENT, cpuUsageMeasurements));
+      }
+      if (!memoryUsageMeasurements.isEmpty()) {
+        measurements.put(
+            ProfileMeasurement.ID_MEMORY_FOOTPRINT,
+            new ProfileMeasurement(ProfileMeasurement.UNIT_BYTES, memoryUsageMeasurements));
+      }
+      if (!nativeMemoryUsageMeasurements.isEmpty()) {
+        measurements.put(
+            ProfileMeasurement.ID_MEMORY_NATIVE_FOOTPRINT,
+            new ProfileMeasurement(ProfileMeasurement.UNIT_BYTES, nativeMemoryUsageMeasurements));
+      }
+    }
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
new file mode 100644
index 00000000000..d09c7252694
--- /dev/null
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoProfiler.java
@@ -0,0 +1,237 @@
+package io.sentry.android.core;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.CancellationSignal;
+import android.os.ProfilingManager;
+import android.os.ProfilingResult;
+import androidx.annotation.RequiresApi;
+import io.sentry.ILogger;
+import io.sentry.ISentryExecutorService;
+import io.sentry.SentryLevel;
+import java.io.File;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.function.Consumer;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Wraps Android's {@link ProfilingManager} API for a single Perfetto stack-sampling session.
+ *
+ * <p>Each instance is single-use: call {@link #start} once, then {@link #endAndCollect} once. For a
+ * new profiling session, create a new instance.
+ */
+@ApiStatus.Internal
+@RequiresApi(api = Build.VERSION_CODES.VANILLA_ICE_CREAM)
+public class PerfettoProfiler {
+
+  // Bundle keys matching ProfilingManager constants
+  private static final String KEY_DURATION_MS = "KEY_DURATION_MS";
+  private static final String KEY_FREQUENCY_HZ = "KEY_FREQUENCY_HZ";
+
+  /**
+   * Fixed sampling frequency for Perfetto stack sampling. Not configurable by the developer. 101Hz
+   * (rather than 100Hz) to avoid lockstep sampling with the display refresh rate (e.g. 60/120fps),
+   * matching the legacy profiler's default sampling rate.
+   */
+  private static final int PROFILING_FREQUENCY_HZ = 101;
+
+  private static final long RESULT_TIMEOUT_MS = 5000;
+
+  private final @NotNull ILogger logger;
+  private final @NotNull ISentryExecutorService executorService;
+  private final @Nullable ProfilingManager profilingManager;
+  private final @NotNull CancellationSignal cancellationSignal = new CancellationSignal();
+
+  private final @NotNull Object profilingResultLock = new Object();
+  private volatile @Nullable ProfilingResult profilingResult = null;
+
+  private @Nullable Consumer<@Nullable File> resultListener = null;
+  private volatile boolean started = false;
+
+  @SuppressLint("WrongConstant")
+  public PerfettoProfiler(
+      final @NotNull Context context,
+      final @NotNull ILogger logger,
+      final @NotNull ISentryExecutorService executorService) {
+    this(
+        logger,
+        executorService,
+        (ProfilingManager) context.getSystemService(Context.PROFILING_SERVICE));
+  }
+
+  PerfettoProfiler(
+      final @NotNull ILogger logger,
+      final @NotNull ISentryExecutorService executorService,
+      final @Nullable ProfilingManager profilingManager) {
+    this.logger = logger;
+    this.executorService = executorService;
+    this.profilingManager = profilingManager;
+  }
+
+  public boolean start(final long durationMs) {
+    if (started) {
+      logger.log(SentryLevel.WARNING, "PerfettoProfiler was already started.");
+      return false;
+    }
+    started = true;
+
+    if (profilingManager == null) {
+      logger.log(SentryLevel.WARNING, "ProfilingManager is not available.");
+      return false;
+    }
+
+    final Bundle params = new Bundle();
+    params.putInt(KEY_DURATION_MS, (int) durationMs);
+    params.putInt(KEY_FREQUENCY_HZ, PROFILING_FREQUENCY_HZ);
+
+    try {
+      profilingManager.requestProfiling(
+          ProfilingManager.PROFILING_TYPE_STACK_SAMPLING,
+          params,
+          "sentry-profiling",
+          cancellationSignal,
+          Runnable::run,
+          this::onProfilingResult);
+    } catch (Throwable e) {
+      logger.log(SentryLevel.ERROR, "Failed to request Profiling.", e);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Cancels the current profiling session. The listener is called with the trace file (or null on
+   * error) once the OS delivers the result. The listener may be called synchronously if the result
+   * has already arrived, or asynchronously on an OS-managed thread otherwise.
+   */
+  public void endAndCollect(final @NotNull Consumer<@Nullable File> listener) {
+    if (!started) {
+      logger.log(SentryLevel.WARNING, "PerfettoProfiler was never started");
+      listener.accept(null);
+      return;
+    }
+
+    cancellationSignal.cancel();
+
+    synchronized (profilingResultLock) {
+      final @Nullable ProfilingResult result = profilingResult;
+      if (result != null) {
+        listener.accept(processResult(result));
+        return;
+      }
+      resultListener = listener;
+    }
+
+    try {
+      executorService.schedule(
+          () -> {
+            synchronized (profilingResultLock) {
+              if (resultListener != null) {
+                logger.log(SentryLevel.WARNING, "Timed out waiting for Perfetto profiling result.");
+                resultListener.accept(null);
+                // Nobody consumes a late result anymore, so delete the trace file instead
+                resultListener = this::deleteTraceFile;
+              }
+            }
+          },
+          RESULT_TIMEOUT_MS);
+    } catch (RejectedExecutionException e) {
+      logger.log(SentryLevel.DEBUG, "Failed to schedule profiling result timeout.", e);
+    }
+  }
+
+  private void onProfilingResult(final @NotNull ProfilingResult result) {
+    logger.log(
+        SentryLevel.DEBUG,
+        "Perfetto ProfilingResult received: errorCode=%d, filePath=%s",
+        result.getErrorCode(),
+        result.getResultFilePath());
+
+    synchronized (profilingResultLock) {
+      profilingResult = result;
+      if (resultListener != null) {
+        resultListener.accept(processResult(result));
+        resultListener = null;
+      }
+    }
+  }
+
+  /**
+   * Deletes a trace file that nobody is going to consume. Called from {@link #onProfilingResult},
+   * which the OS delivers on a binder thread, so deleting inline is fine.
+   */
+  private void deleteTraceFile(final @Nullable File traceFile) {
+    if (traceFile == null) {
+      return;
+    }
+    if (!traceFile.delete()) {
+      logger.log(
+          SentryLevel.WARNING, "Failed to delete late Perfetto trace file %s", traceFile.getPath());
+    }
+  }
+
+  private @Nullable File processResult(final @NotNull ProfilingResult result) {
+    final int errorCode = result.getErrorCode();
+    if (errorCode != ProfilingResult.ERROR_NONE) {
+      switch (errorCode) {
+        case ProfilingResult.ERROR_FAILED_RATE_LIMIT_PROCESS:
+        case ProfilingResult.ERROR_FAILED_RATE_LIMIT_SYSTEM:
+          logger.log(
+              SentryLevel.INFO,
+              "Perfetto profiling failed: %s."
+                  + " To disable during development run:"
+                  + " adb shell device_config put profiling_testing rate_limiter.disabled true",
+              errorCodeToString(errorCode));
+          break;
+        default:
+          logger.log(
+              SentryLevel.WARNING,
+              "Perfetto profiling failed with %s (error code %d): %s."
+                  + " See https://developer.android.com/reference/android/os/ProfilingResult",
+              errorCodeToString(errorCode),
+              errorCode,
+              result.getErrorMessage());
+          break;
+      }
+      return null;
+    }
+
+    final @Nullable String resultFilePath = result.getResultFilePath();
+    if (resultFilePath == null) {
+      logger.log(SentryLevel.WARNING, "Perfetto profiling result file path is null.");
+      return null;
+    }
+
+    final File traceFile = new File(resultFilePath);
+    if (!traceFile.exists() || traceFile.length() == 0) {
+      logger.log(SentryLevel.WARNING, "Perfetto trace file does not exist or is empty.");
+      return null;
+    }
+
+    return traceFile;
+  }
+
+  private static @NotNull String errorCodeToString(final int errorCode) {
+    switch (errorCode) {
+      case ProfilingResult.ERROR_FAILED_RATE_LIMIT_PROCESS:
+        return "ERROR_FAILED_RATE_LIMIT_PROCESS";
+      case ProfilingResult.ERROR_FAILED_RATE_LIMIT_SYSTEM:
+        return "ERROR_FAILED_RATE_LIMIT_SYSTEM";
+      case ProfilingResult.ERROR_FAILED_INVALID_REQUEST:
+        return "ERROR_FAILED_INVALID_REQUEST";
+      case ProfilingResult.ERROR_FAILED_PROFILING_IN_PROGRESS:
+        return "ERROR_FAILED_PROFILING_IN_PROGRESS";
+      case ProfilingResult.ERROR_FAILED_POST_PROCESSING:
+        return "ERROR_FAILED_POST_PROCESSING";
+      case ProfilingResult.ERROR_UNKNOWN:
+        return "ERROR_UNKNOWN";
+      default:
+        return "UNKNOWN_ERROR_CODE";
+    }
+  }
+}
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
index 7e43d626b34..c85fe12674d 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
@@ -129,6 +129,23 @@ private void launchAppStartProfiler(final @NotNull AppStartMetrics appStartMetri
         return;
       }
 
+      if (buildInfoProvider.getSdkInfoVersion()
+          >= android.os.Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+        logger.log(
+            SentryLevel.DEBUG,
+            "Device is API 35+. Skipping legacy app-start profiling — "
+                + "Perfetto ProfilingManager will be initialized after Sentry.init().");
+        return;
+      }
+
+      if (!profilingOptions.isEnableLegacyProfiling()) {
+        logger.log(
+            SentryLevel.WARNING,
+            "enableLegacyProfiling is disabled and device is below API 35. "
+                + "App start profiling will not start.");
+        return;
+      }
+
       if (profilingOptions.isContinuousProfilingEnabled()
           && profilingOptions.isStartProfilerOnAppStart()) {
         createAndStartContinuousProfiler(context, profilingOptions, appStartMetrics);
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
index 8837030608e..caaa30152a4 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidContinuousProfilerTest.kt
@@ -5,7 +5,6 @@ import android.os.Build
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.CompositePerformanceCollector
-import io.sentry.DataCategory
 import io.sentry.IConnectionStatusProvider
 import io.sentry.ILogger
 import io.sentry.IScopes
@@ -18,10 +17,8 @@ import io.sentry.TracesSampler
 import io.sentry.TransactionContext
 import io.sentry.android.core.internal.util.SentryFrameMetricsCollector
 import io.sentry.profilemeasurements.ProfileMeasurement
-import io.sentry.protocol.SentryId
 import io.sentry.test.DeferredExecutorService
 import io.sentry.test.getProperty
-import io.sentry.transport.RateLimiter
 import java.io.File
 import java.util.concurrent.Future
 import kotlin.test.AfterTest
@@ -30,12 +27,10 @@ import kotlin.test.Test
 import kotlin.test.assertContains
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
-import kotlin.test.assertNotEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
-import org.mockito.Mockito
 import org.mockito.Mockito.mockStatic
 import org.mockito.kotlin.any
 import org.mockito.kotlin.check
@@ -51,6 +46,7 @@ import org.mockito.kotlin.whenever
 class AndroidContinuousProfilerTest {
   private lateinit var context: Context
   private val fixture = Fixture()
+  private lateinit var mocks: ProfilerMocks
 
   private class Fixture {
     private val mockDsn = "http://key@localhost/proj"
@@ -143,6 +139,8 @@ class AndroidContinuousProfilerTest {
     Sentry.setCurrentScopes(fixture.scopes)
 
     fixture.mockedSentry.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(fixture.scopes)
+    mocks =
+      ProfilerMocks(fixture.executor, fixture.mockTracesSampler, fixture.mockLogger, fixture.scopes)
   }
 
   @AfterTest
@@ -151,110 +149,148 @@ class AndroidContinuousProfilerTest {
     fixture.mockedSentry.close()
   }
 
+  // -- TODO: Could be shared with PerfettoContinuousProfiler with some refactoring --
+
   @Test
-  fun `isRunning reflects profiler status`() {
-    val profiler = fixture.getSut()
+  fun `profiler ignores profilesSampleRate`() {
+    val profiler = fixture.getSut { it.profilesSampleRate = 0.0 }
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
     assertTrue(profiler.isRunning)
-    profiler.stopProfiler(ProfileLifecycle.MANUAL)
-    fixture.executor.runAll()
-    assertFalse(profiler.isRunning)
   }
 
   @Test
-  fun `stopProfiler stops the profiler after chunk is finished`() {
+  fun `profiler starts performance collector on start`() {
+    val performanceCollector = mock<CompositePerformanceCollector>()
+    fixture.options.compositePerformanceCollector = performanceCollector
     val profiler = fixture.getSut()
+    verify(performanceCollector, never()).start(any<String>())
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertTrue(profiler.isRunning)
-    // We are scheduling the profiler to stop at the end of the chunk, so it should still be running
+    verify(performanceCollector).start(any<String>())
+  }
+
+  @Test
+  fun `profiler stops performance collector on stop`() {
+    val performanceCollector = mock<CompositePerformanceCollector>()
+    fixture.options.compositePerformanceCollector = performanceCollector
+    val profiler = fixture.getSut()
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    verify(performanceCollector, never()).stop(any<String>())
     profiler.stopProfiler(ProfileLifecycle.MANUAL)
-    assertTrue(profiler.isRunning)
-    assertNotEquals(SentryId.EMPTY_ID, profiler.profilerId)
-    assertNotEquals(SentryId.EMPTY_ID, profiler.chunkId)
-    // We run the executor service to trigger the chunk finish, and the profiler shouldn't restart
     fixture.executor.runAll()
-    assertFalse(profiler.isRunning)
-    assertEquals(SentryId.EMPTY_ID, profiler.profilerId)
-    assertEquals(SentryId.EMPTY_ID, profiler.chunkId)
+    verify(performanceCollector).stop(any<String>())
   }
 
   @Test
-  fun `profiler multiple starts are ignored in manual mode`() {
+  fun `profiler stops collecting frame metrics when it stops`() {
     val profiler = fixture.getSut()
+    val frameMetricsCollectorId = "id"
+    whenever(fixture.frameMetricsCollector.startCollection(any()))
+      .thenReturn(frameMetricsCollectorId)
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertTrue(profiler.isRunning)
-    verify(fixture.mockLogger, never())
-      .log(eq(SentryLevel.DEBUG), eq("Profiler is already running."))
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    verify(fixture.mockLogger).log(eq(SentryLevel.DEBUG), eq("Profiler is already running."))
-    assertTrue(profiler.isRunning)
-    assertEquals(0, profiler.rootSpanCounter)
+    verify(fixture.frameMetricsCollector, never()).stopCollection(frameMetricsCollectorId)
+    profiler.stopProfiler(ProfileLifecycle.MANUAL)
+    fixture.executor.runAll()
+    verify(fixture.frameMetricsCollector).stopCollection(frameMetricsCollectorId)
   }
 
   @Test
-  fun `profiler multiple starts are accepted in trace mode`() {
-    val profiler = fixture.getSut()
+  fun `profiler sends chunk with measurements`() {
+    val performanceCollector = mock<CompositePerformanceCollector>()
+    val collectionData = PerformanceCollectionData(10)
 
-    // rootSpanCounter is incremented when the profiler starts in trace mode
-    assertEquals(0, profiler.rootSpanCounter)
-    profiler.startProfiler(ProfileLifecycle.TRACE, fixture.mockTracesSampler)
-    assertEquals(1, profiler.rootSpanCounter)
-    assertTrue(profiler.isRunning)
-    profiler.startProfiler(ProfileLifecycle.TRACE, fixture.mockTracesSampler)
-    verify(fixture.mockLogger, never())
-      .log(eq(SentryLevel.DEBUG), eq("Profiler is already running."))
-    assertTrue(profiler.isRunning)
-    assertEquals(2, profiler.rootSpanCounter)
+    collectionData.usedHeapMemory = 2
+    collectionData.usedNativeMemory = 3
+    collectionData.cpuUsagePercentage = 3.0
+    whenever(performanceCollector.stop(any<String>())).thenReturn(listOf(collectionData))
 
-    // rootSpanCounter is decremented when the profiler stops in trace mode, and keeps running until
-    // rootSpanCounter is 0
-    profiler.stopProfiler(ProfileLifecycle.TRACE)
+    fixture.options.compositePerformanceCollector = performanceCollector
+    val profiler = fixture.getSut()
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    profiler.stopProfiler(ProfileLifecycle.MANUAL)
     fixture.executor.runAll()
-    assertEquals(1, profiler.rootSpanCounter)
-    assertTrue(profiler.isRunning)
-
-    // only when rootSpanCounter is 0 the profiler stops
-    profiler.stopProfiler(ProfileLifecycle.TRACE)
     fixture.executor.runAll()
-    assertEquals(0, profiler.rootSpanCounter)
-    assertFalse(profiler.isRunning)
+    verify(fixture.scopes)
+      .captureProfileChunk(
+        check {
+          assertContains(it.measurements, ProfileMeasurement.ID_CPU_USAGE)
+          assertContains(it.measurements, ProfileMeasurement.ID_MEMORY_FOOTPRINT)
+          assertContains(it.measurements, ProfileMeasurement.ID_MEMORY_NATIVE_FOOTPRINT)
+        }
+      )
   }
 
+  // -- Shared tests (see ContinuousProfilerTestCases.kt) --
+
   @Test
-  fun `profiler logs a warning on start if not sampled`() {
-    val profiler = fixture.getSut()
-    whenever(fixture.mockTracesSampler.sampleSessionProfile(any())).thenReturn(false)
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertFalse(profiler.isRunning)
-    verify(fixture.mockLogger)
-      .log(eq(SentryLevel.DEBUG), eq("Profiler was not started due to sampling decision."))
-  }
+  fun `isRunning reflects profiler status`() = fixture.getSut().testIsRunningReflectsStatus(mocks)
 
   @Test
-  fun `profiler evaluates sessionSampleRate only the first time`() {
-    val profiler = fixture.getSut()
-    verify(fixture.mockTracesSampler, never()).sampleSessionProfile(any())
-    // The first time the profiler is started, the sessionSampleRate is evaluated
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    verify(fixture.mockTracesSampler, times(1)).sampleSessionProfile(any())
-    // Then, the sessionSampleRate is not evaluated again
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    verify(fixture.mockTracesSampler, times(1)).sampleSessionProfile(any())
-  }
+  fun `stopProfiler stops the profiler after chunk is finished`() =
+    fixture.getSut().testStopProfilerStopsAfterChunkFinished(mocks)
+
+  @Test
+  fun `profiler multiple starts are accepted in trace mode`() =
+    fixture.getSut().testMultipleStartsAcceptedInTraceMode(mocks)
+
+  @Test
+  fun `profiler logs a warning on start if not sampled`() =
+    fixture.getSut().testLogsWarningIfNotSampled(mocks)
+
+  @Test
+  fun `profiler evaluates sessionSampleRate only the first time`() =
+    fixture.getSut().testEvaluatesSessionSampleRateOnlyOnce(mocks)
+
+  @Test
+  fun `when reevaluateSampling, profiler evaluates sessionSampleRate on next start`() =
+    fixture.getSut().testReevaluateSamplingOnNextStart(mocks)
+
+  @Test
+  fun `profiler stops and restart for each chunk`() =
+    fixture.getSut().testStopsAndRestartsForEachChunk(mocks)
+
+  @Test
+  fun `profiler sends chunk on each restart`() = fixture.getSut().testSendsChunkOnRestart(mocks)
+
+  @Test fun `profiler sends another chunk on stop`() = fixture.getSut().testSendsChunkOnStop(mocks)
+
+  @Test
+  fun `close without terminating stops all profiles after chunk is finished`() =
+    fixture.getSut().testCloseWithoutTerminatingStopsAfterChunk(mocks)
+
+  @Test
+  fun `profiler does not send chunks after close`() =
+    fixture.getSut().testDoesNotSendChunksAfterClose(mocks)
+
+  @Test fun `profiler stops when rate limited`() = fixture.getSut().testStopsWhenRateLimited(mocks)
 
   @Test
-  fun `when reevaluateSampling, profiler evaluates sessionSampleRate on next start`() {
+  fun `profiler does not start when rate limited`() =
+    fixture.getSut().testDoesNotStartWhenRateLimited(mocks)
+
+  @Test
+  fun `profiler does not start when offline`() =
+    fixture
+      .getSut {
+        it.connectionStatusProvider = mock { provider ->
+          whenever(provider.connectionStatus)
+            .thenReturn(IConnectionStatusProvider.ConnectionStatus.DISCONNECTED)
+        }
+      }
+      .testDoesNotStartWhenOffline(mocks)
+
+  // -- Legacy-specific tests (AndroidContinuousProfiler only) --
+
+  @Test
+  fun `profiler multiple starts are ignored in manual mode`() {
     val profiler = fixture.getSut()
-    verify(fixture.mockTracesSampler, never()).sampleSessionProfile(any())
-    // The first time the profiler is started, the sessionSampleRate is evaluated
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    verify(fixture.mockTracesSampler, times(1)).sampleSessionProfile(any())
-    // When reevaluateSampling is called, the sessionSampleRate is not evaluated immediately
-    profiler.reevaluateSampling()
-    verify(fixture.mockTracesSampler, times(1)).sampleSessionProfile(any())
-    // Then, when the profiler starts again, the sessionSampleRate is reevaluated
+    assertTrue(profiler.isRunning)
+    verify(fixture.mockLogger, never())
+      .log(eq(SentryLevel.DEBUG), eq("Profiler is already running."))
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    verify(fixture.mockTracesSampler, times(2)).sampleSessionProfile(any())
+    verify(fixture.mockLogger).log(eq(SentryLevel.DEBUG), eq("Profiler is already running."))
+    assertTrue(profiler.isRunning)
+    assertEquals(0, profiler.rootSpanCounter)
   }
 
   @Test
@@ -268,25 +304,14 @@ class AndroidContinuousProfilerTest {
     assertFalse(profiler.isRunning)
   }
 
-  @Test
-  fun `profiler ignores profilesSampleRate`() {
-    val profiler = fixture.getSut { it.profilesSampleRate = 0.0 }
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertTrue(profiler.isRunning)
-  }
-
   @Test
   fun `profiler evaluates profilingTracesDirPath options only on first start`() {
-    // We create the profiler, and nothing goes wrong
     val profiler = fixture.getSut { it.cacheDirPath = null }
     verify(fixture.mockLogger, never())
       .log(
         SentryLevel.WARNING,
         "Disabling profiling because no profiling traces dir path is defined in options.",
       )
-
-    // Regardless of how many times the profiler is started, the option is evaluated and logged only
-    // once
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
     verify(fixture.mockLogger, times(1))
@@ -298,13 +323,9 @@ class AndroidContinuousProfilerTest {
 
   @Test
   fun `profiler evaluates profilingTracesHz options only on first start`() {
-    // We create the profiler, and nothing goes wrong
     val profiler = fixture.getSut { it.profilingTracesHz = 0 }
     verify(fixture.mockLogger, never())
       .log(SentryLevel.WARNING, "Disabling profiling because trace rate is set to %d", 0)
-
-    // Regardless of how many times the profiler is started, the option is evaluated and logged only
-    // once
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
     verify(fixture.mockLogger, times(1))
@@ -338,47 +359,11 @@ class AndroidContinuousProfilerTest {
     profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
     profiler.stopProfiler(ProfileLifecycle.MANUAL)
     fixture.executor.runAll()
-    // We assert that no trace files are written
     assertTrue(File(fixture.options.profilingTracesDirPath!!).list()!!.isEmpty())
     verify(fixture.mockLogger)
       .log(eq(SentryLevel.ERROR), eq("Error while stopping profiling: "), any())
   }
 
-  @Test
-  fun `profiler starts performance collector on start`() {
-    val performanceCollector = mock<CompositePerformanceCollector>()
-    fixture.options.compositePerformanceCollector = performanceCollector
-    val profiler = fixture.getSut()
-    verify(performanceCollector, never()).start(any<String>())
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    verify(performanceCollector).start(any<String>())
-  }
-
-  @Test
-  fun `profiler stops performance collector on stop`() {
-    val performanceCollector = mock<CompositePerformanceCollector>()
-    fixture.options.compositePerformanceCollector = performanceCollector
-    val profiler = fixture.getSut()
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    verify(performanceCollector, never()).stop(any<String>())
-    profiler.stopProfiler(ProfileLifecycle.MANUAL)
-    fixture.executor.runAll()
-    verify(performanceCollector).stop(any<String>())
-  }
-
-  @Test
-  fun `profiler stops collecting frame metrics when it stops`() {
-    val profiler = fixture.getSut()
-    val frameMetricsCollectorId = "id"
-    whenever(fixture.frameMetricsCollector.startCollection(any()))
-      .thenReturn(frameMetricsCollectorId)
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    verify(fixture.frameMetricsCollector, never()).stopCollection(frameMetricsCollectorId)
-    profiler.stopProfiler(ProfileLifecycle.MANUAL)
-    fixture.executor.runAll()
-    verify(fixture.frameMetricsCollector).stopCollection(frameMetricsCollectorId)
-  }
-
   @Test
   fun `profiler stops profiling and clear scheduled job on close`() {
     val profiler = fixture.getSut()
@@ -388,7 +373,6 @@ class AndroidContinuousProfilerTest {
     profiler.close(true)
     assertFalse(profiler.isRunning)
 
-    // The timeout scheduled job should be cleared
     val androidProfiler = profiler.getProperty<AndroidProfiler?>("profiler")
     val scheduledJob = androidProfiler?.getProperty<Future<*>?>("scheduledFinish")
     assertNull(scheduledJob)
@@ -398,165 +382,8 @@ class AndroidContinuousProfilerTest {
     assertTrue(stopFuture.isCancelled || stopFuture.isDone)
   }
 
-  @Test
-  fun `profiler stops and restart for each chunk`() {
-    val profiler = fixture.getSut()
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertTrue(profiler.isRunning)
-    val oldChunkId = profiler.chunkId
-
-    fixture.executor.runAll()
-    verify(fixture.mockLogger)
-      .log(eq(SentryLevel.DEBUG), eq("Profile chunk finished. Starting a new one."))
-    assertTrue(profiler.isRunning)
-
-    fixture.executor.runAll()
-    verify(fixture.mockLogger, times(2))
-      .log(eq(SentryLevel.DEBUG), eq("Profile chunk finished. Starting a new one."))
-    assertTrue(profiler.isRunning)
-    assertNotEquals(oldChunkId, profiler.chunkId)
-  }
-
-  @Test
-  fun `profiler sends chunk on each restart`() {
-    val profiler = fixture.getSut()
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertTrue(profiler.isRunning)
-    // We run the executor service to trigger the profiler restart (chunk finish)
-    fixture.executor.runAll()
-    verify(fixture.scopes, never()).captureProfileChunk(any())
-    // Now the executor is used to send the chunk
-    fixture.executor.runAll()
-    verify(fixture.scopes).captureProfileChunk(any())
-  }
-
-  @Test
-  fun `profiler sends chunk with measurements`() {
-    val performanceCollector = mock<CompositePerformanceCollector>()
-    val collectionData = PerformanceCollectionData(10)
-
-    collectionData.usedHeapMemory = 2
-    collectionData.usedNativeMemory = 3
-    collectionData.cpuUsagePercentage = 3.0
-    whenever(performanceCollector.stop(any<String>())).thenReturn(listOf(collectionData))
-
-    fixture.options.compositePerformanceCollector = performanceCollector
-    val profiler = fixture.getSut()
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    profiler.stopProfiler(ProfileLifecycle.MANUAL)
-    // We run the executor service to stop the profiler
-    fixture.executor.runAll()
-    // Then we run it again to send the profile chunk
-    fixture.executor.runAll()
-    verify(fixture.scopes)
-      .captureProfileChunk(
-        check {
-          assertContains(it.measurements, ProfileMeasurement.ID_CPU_USAGE)
-          assertContains(it.measurements, ProfileMeasurement.ID_MEMORY_FOOTPRINT)
-          assertContains(it.measurements, ProfileMeasurement.ID_MEMORY_NATIVE_FOOTPRINT)
-        }
-      )
-  }
-
-  @Test
-  fun `profiler sends another chunk on stop`() {
-    val profiler = fixture.getSut()
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertTrue(profiler.isRunning)
-    // We run the executor service to trigger the profiler restart (chunk finish)
-    fixture.executor.runAll()
-    verify(fixture.scopes, never()).captureProfileChunk(any())
-    profiler.stopProfiler(ProfileLifecycle.MANUAL)
-    // We stop the profiler, which should send a chunk
-    fixture.executor.runAll()
-    verify(fixture.scopes).captureProfileChunk(any())
-  }
-
-  @Test
-  fun `close without terminating stops all profiles after chunk is finished`() {
-    val profiler = fixture.getSut()
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    profiler.startProfiler(ProfileLifecycle.TRACE, fixture.mockTracesSampler)
-    assertTrue(profiler.isRunning)
-    // We are scheduling the profiler to stop at the end of the chunk, so it should still be running
-    profiler.close(false)
-    assertTrue(profiler.isRunning)
-    // However, close() already resets the rootSpanCounter
-    assertEquals(0, profiler.rootSpanCounter)
-
-    // We run the executor service to trigger the chunk finish, and the profiler shouldn't restart
-    fixture.executor.runAll()
-    assertFalse(profiler.isRunning)
-  }
-
-  @Test
-  fun `profiler does not send chunks after close`() {
-    val profiler = fixture.getSut()
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertTrue(profiler.isRunning)
-
-    // We close the profiler, which should prevent sending additional chunks
-    profiler.close(true)
-
-    // The executor used to send the chunk doesn't do anything
-    fixture.executor.runAll()
-    verify(fixture.scopes, never()).captureProfileChunk(any())
-  }
-
-  @Test
-  fun `profiler stops when rate limited`() {
-    val profiler = fixture.getSut()
-    val rateLimiter = mock<RateLimiter>()
-    whenever(rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi)).thenReturn(true)
-
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertTrue(profiler.isRunning)
-
-    // If the SDK is rate limited, the profiler should stop
-    profiler.onRateLimitChanged(rateLimiter)
-    assertFalse(profiler.isRunning)
-    assertEquals(SentryId.EMPTY_ID, profiler.profilerId)
-    assertEquals(SentryId.EMPTY_ID, profiler.chunkId)
-    verify(fixture.mockLogger)
-      .log(eq(SentryLevel.WARNING), eq("SDK is rate limited. Stopping profiler."))
-  }
-
-  @Test
-  fun `profiler does not start when rate limited`() {
-    val profiler = fixture.getSut()
-    val rateLimiter = mock<RateLimiter>()
-    whenever(rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi)).thenReturn(true)
-    whenever(fixture.scopes.rateLimiter).thenReturn(rateLimiter)
-
-    // If the SDK is rate limited, the profiler should never start
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertFalse(profiler.isRunning)
-    assertEquals(SentryId.EMPTY_ID, profiler.profilerId)
-    assertEquals(SentryId.EMPTY_ID, profiler.chunkId)
-    verify(fixture.mockLogger)
-      .log(eq(SentryLevel.WARNING), eq("SDK is rate limited. Stopping profiler."))
-  }
-
-  @Test
-  fun `profiler does not start when offline`() {
-    val profiler = fixture.getSut {
-      it.connectionStatusProvider = mock { provider ->
-        whenever(provider.connectionStatus)
-          .thenReturn(IConnectionStatusProvider.ConnectionStatus.DISCONNECTED)
-      }
-    }
-
-    // If the device is offline, the profiler should never start
-    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
-    assertFalse(profiler.isRunning)
-    assertEquals(SentryId.EMPTY_ID, profiler.profilerId)
-    assertEquals(SentryId.EMPTY_ID, profiler.chunkId)
-    verify(fixture.mockLogger)
-      .log(eq(SentryLevel.WARNING), eq("Device is offline. Stopping profiler."))
-  }
-
   fun withMockScopes(closure: () -> Unit) =
-    Mockito.mockStatic(Sentry::class.java).use {
+    mockStatic(Sentry::class.java).use {
       it.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(fixture.scopes)
       closure.invoke()
     }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
index cbe42faa103..6df1ed7167e 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidOptionsInitializerTest.kt
@@ -376,6 +376,27 @@ class AndroidOptionsInitializerTest {
     assertTrue(fixture.sentryOptions.continuousProfiler is AndroidContinuousProfiler)
   }
 
+  @Config(sdk = [35])
+  @Test
+  fun `init on API 35+ always sets PerfettoContinuousProfiler`() {
+    fixture.initSut()
+    assertTrue(fixture.sentryOptions.continuousProfiler is PerfettoContinuousProfiler)
+  }
+
+  @Config(sdk = [34])
+  @Test
+  fun `init below API 35 with enableLegacyProfiling true sets AndroidContinuousProfiler`() {
+    fixture.initSut(configureOptions = { isEnableLegacyProfiling = true })
+    assertTrue(fixture.sentryOptions.continuousProfiler is AndroidContinuousProfiler)
+  }
+
+  @Config(sdk = [34])
+  @Test
+  fun `init below API 35 with enableLegacyProfiling false noops profiler`() {
+    fixture.initSut(configureOptions = { isEnableLegacyProfiling = false })
+    assertTrue(fixture.sentryOptions.continuousProfiler is NoOpContinuousProfiler)
+  }
+
   @Test
   fun `init with profilesSampleRate should set Android transaction profiler`() {
     fixture.initSut(configureOptions = { profilesSampleRate = 1.0 })
@@ -403,6 +424,51 @@ class AndroidOptionsInitializerTest {
     assertEquals(fixture.sentryOptions.continuousProfiler, NoOpContinuousProfiler.getInstance())
   }
 
+  @Test
+  fun `init with profilesSampleRate and enableLegacyProfiling false noops both profilers`() {
+    fixture.initSut(
+      configureOptions = {
+        profilesSampleRate = 1.0
+        isEnableLegacyProfiling = false
+      }
+    )
+
+    assertEquals(NoOpTransactionProfiler.getInstance(), fixture.sentryOptions.transactionProfiler)
+    assertEquals(NoOpContinuousProfiler.getInstance(), fixture.sentryOptions.continuousProfiler)
+  }
+
+  @Test
+  fun `init with profilesSampler and enableLegacyProfiling false noops both profilers`() {
+    fixture.initSut(
+      configureOptions = {
+        profilesSampler = mock()
+        isEnableLegacyProfiling = false
+      }
+    )
+
+    assertEquals(NoOpTransactionProfiler.getInstance(), fixture.sentryOptions.transactionProfiler)
+    assertEquals(NoOpContinuousProfiler.getInstance(), fixture.sentryOptions.continuousProfiler)
+  }
+
+  @Test
+  fun `init with profilesSampleRate and enableLegacyProfiling false closes app start profiler`() {
+    val appStartProfiler = mock<ITransactionProfiler>()
+    AppStartMetrics.getInstance().appStartProfiler = appStartProfiler
+    fixture.initSut(
+      configureOptions = {
+        profilesSampleRate = 1.0
+        isEnableLegacyProfiling = false
+      }
+    )
+
+    assertEquals(NoOpTransactionProfiler.getInstance(), fixture.sentryOptions.transactionProfiler)
+    verify(appStartProfiler).close()
+
+    // AppStartMetrics should be cleared
+    assertNull(AppStartMetrics.getInstance().appStartProfiler)
+    assertNull(AppStartMetrics.getInstance().appStartContinuousProfiler)
+  }
+
   @Test
   fun `init reuses transaction profiler of appStartMetrics, if exists`() {
     val appStartProfiler = mock<ITransactionProfiler>()
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ChunkMeasurementCollectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ChunkMeasurementCollectorTest.kt
new file mode 100644
index 00000000000..ffc00907460
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ChunkMeasurementCollectorTest.kt
@@ -0,0 +1,146 @@
+package io.sentry.android.core
+
+import io.sentry.CompositePerformanceCollector
+import io.sentry.PerformanceCollectionData
+import io.sentry.android.core.internal.util.SentryFrameMetricsCollector
+import io.sentry.profilemeasurements.ProfileMeasurement
+import java.util.concurrent.TimeUnit
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class ChunkMeasurementCollectorTest {
+
+  /**
+   * Drives [PerfettoContinuousProfiler.ChunkMeasurementCollector] through two full `start ->
+   * collect -> stop` cycles to assert that the metrics collected are correct.
+   */
+  @Test
+  fun `each start-stop cycle returns its own independent measurements`() {
+    val frameMetricsCollector: SentryFrameMetricsCollector = mock()
+    val performanceCollector: CompositePerformanceCollector = mock()
+    val collector = PerfettoContinuousProfiler.ChunkMeasurementCollector(frameMetricsCollector)
+    val listenerCaptor = argumentCaptor<SentryFrameMetricsCollector.FrameMetricsCollectorListener>()
+
+    // Return distinct performance data for each stop() call.
+    whenever(performanceCollector.stop(any<String>()))
+      .thenReturn(
+        // Cycle 1: 2 samples, both with cpu + heap, only first with native.
+        listOf(
+          perfData(nanos = 100L, cpu = 10.0, heap = 1_000L, native = 500L),
+          perfData(nanos = 200L, cpu = 20.0, heap = 2_000L, native = null),
+        ),
+        // Cycle 2: 3 samples, all with heap, only some with cpu/native.
+        listOf(
+          perfData(nanos = 1_000L, cpu = 30.0, heap = 3_000L, native = null),
+          perfData(nanos = 1_100L, cpu = null, heap = 4_000L, native = 800L),
+          perfData(nanos = 1_200L, cpu = 50.0, heap = 5_000L, native = 900L),
+        ),
+      )
+
+    // --- Cycle 1 ---
+    collector.start(performanceCollector, "chunk-1")
+    verify(frameMetricsCollector).startCollection(listenerCaptor.capture())
+    // frameEndNanos comes from System.nanoTime(), so it must be based on the current reading for
+    // the resulting chunk-relative timestamp to be non-negative.
+    var frameEnd = futureFrameEndNanos()
+    // onFrameMetricCollected(frameStart, frameEnd, duration, delay, isSlow, isFrozen, refreshRate)
+    listenerCaptor.lastValue.apply {
+      onFrameMetricCollected(0L, frameEnd, 100L, 0L, true, false, 60.0f) // slow
+      onFrameMetricCollected(0L, frameEnd, 800L, 0L, false, true, 60.0f) // frozen
+      onFrameMetricCollected(0L, frameEnd, 50L, 0L, false, false, 90.0f) // refresh change
+    }
+    val chunk1 = collector.stop()
+
+    // --- Cycle 2 ---
+    collector.start(performanceCollector, "chunk-2")
+    verify(frameMetricsCollector, times(2)).startCollection(listenerCaptor.capture())
+    frameEnd = futureFrameEndNanos()
+    listenerCaptor.lastValue.apply {
+      onFrameMetricCollected(0L, frameEnd, 150L, 0L, true, false, 60.0f) // slow
+      onFrameMetricCollected(0L, frameEnd, 200L, 0L, true, false, 60.0f) // slow
+      onFrameMetricCollected(0L, frameEnd, 900L, 0L, false, true, 60.0f) // frozen
+    }
+    val chunk2 = collector.stop()
+
+    // Cycle 1: 1 slow, 1 frozen; refresh rate goes 0 -> 60 -> 90 (2 changes recorded);
+    // 2 cpu samples, 2 heap samples, 1 native sample.
+    assertChunkCounts(chunk1, slow = 1, frozen = 1, refreshRate = 2, cpu = 2, heap = 2, native = 1)
+    // Cycle 2: 2 slow, 1 frozen; refresh rate goes 0 -> 60 (1 change recorded);
+    // 2 cpu samples (one was null), 3 heap samples, 2 native samples.
+    assertChunkCounts(chunk2, slow = 2, frozen = 1, refreshRate = 1, cpu = 2, heap = 3, native = 2)
+  }
+
+  @Test
+  fun `frames ending before the chunk started are dropped`() {
+    val frameMetricsCollector: SentryFrameMetricsCollector = mock()
+    val collector = PerfettoContinuousProfiler.ChunkMeasurementCollector(frameMetricsCollector)
+    val listenerCaptor = argumentCaptor<SentryFrameMetricsCollector.FrameMetricsCollectorListener>()
+
+    collector.start(null, "chunk-1")
+    verify(frameMetricsCollector).startCollection(listenerCaptor.capture())
+
+    val staleFrameEnd = System.nanoTime() - TimeUnit.HOURS.toNanos(1)
+    listenerCaptor.lastValue.apply {
+      onFrameMetricCollected(0L, staleFrameEnd, 100L, 0L, true, false, 60.0f)
+      onFrameMetricCollected(0L, staleFrameEnd, 800L, 0L, false, true, 60.0f)
+      onFrameMetricCollected(0L, futureFrameEndNanos(), 150L, 0L, true, false, 60.0f)
+    }
+
+    val measurements = collector.stop()
+
+    assertChunkCounts(
+      measurements,
+      slow = 1,
+      frozen = 0,
+      refreshRate = 1,
+      cpu = 0,
+      heap = 0,
+      native = 0,
+    )
+  }
+
+  /**
+   * A frameEndNanos far enough ahead of the collector's own `System.nanoTime()` reading that the
+   * chunk-relative timestamp stays positive regardless of test execution timing.
+   */
+  private fun futureFrameEndNanos() = System.nanoTime() + TimeUnit.MINUTES.toNanos(1)
+
+  private fun perfData(nanos: Long, cpu: Double?, heap: Long?, native: Long?) =
+    PerformanceCollectionData(nanos).apply {
+      cpuUsagePercentage = cpu
+      usedHeapMemory = heap
+      usedNativeMemory = native
+    }
+
+  private fun assertChunkCounts(
+    measurements: Map<String, ProfileMeasurement>,
+    slow: Int,
+    frozen: Int,
+    refreshRate: Int,
+    cpu: Int,
+    heap: Int,
+    native: Int,
+  ) {
+    assertEquals(slow, measurements[ProfileMeasurement.ID_SLOW_FRAME_RENDERS]?.values?.size ?: 0)
+    assertEquals(
+      frozen,
+      measurements[ProfileMeasurement.ID_FROZEN_FRAME_RENDERS]?.values?.size ?: 0,
+    )
+    assertEquals(
+      refreshRate,
+      measurements[ProfileMeasurement.ID_SCREEN_FRAME_RATES]?.values?.size ?: 0,
+    )
+    assertEquals(cpu, measurements[ProfileMeasurement.ID_CPU_USAGE]?.values?.size ?: 0)
+    assertEquals(heap, measurements[ProfileMeasurement.ID_MEMORY_FOOTPRINT]?.values?.size ?: 0)
+    assertEquals(
+      native,
+      measurements[ProfileMeasurement.ID_MEMORY_NATIVE_FOOTPRINT]?.values?.size ?: 0,
+    )
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ContinuousProfilerTestCases.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ContinuousProfilerTestCases.kt
new file mode 100644
index 00000000000..5e4e0504ddf
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ContinuousProfilerTestCases.kt
@@ -0,0 +1,194 @@
+package io.sentry.android.core
+
+import io.sentry.DataCategory
+import io.sentry.IContinuousProfiler
+import io.sentry.ILogger
+import io.sentry.IScopes
+import io.sentry.ProfileLifecycle
+import io.sentry.SentryLevel
+import io.sentry.TracesSampler
+import io.sentry.protocol.SentryId
+import io.sentry.test.DeferredExecutorService
+import io.sentry.transport.RateLimiter
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotEquals
+import kotlin.test.assertTrue
+import org.mockito.kotlin.any
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
+import org.mockito.kotlin.times
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+/**
+ * Shared dependencies for profiler test cases. Each test class creates one from its own fixture.
+ */
+class ProfilerMocks(
+  val executor: DeferredExecutorService,
+  val tracesSampler: TracesSampler,
+  val logger: ILogger,
+  val scopes: IScopes,
+)
+
+// -- Shared test cases as extension functions on IContinuousProfiler --
+
+fun IContinuousProfiler.testIsRunningReflectsStatus(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertTrue(isRunning)
+  stopProfiler(ProfileLifecycle.MANUAL)
+  mocks.executor.runAll()
+  assertFalse(isRunning)
+}
+
+fun IContinuousProfiler.testStopProfilerStopsAfterChunkFinished(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertTrue(isRunning)
+  stopProfiler(ProfileLifecycle.MANUAL)
+  assertTrue(isRunning)
+  assertNotEquals(SentryId.EMPTY_ID, profilerId)
+  assertNotEquals(SentryId.EMPTY_ID, chunkId)
+  mocks.executor.runAll()
+  assertFalse(isRunning)
+  assertEquals(SentryId.EMPTY_ID, profilerId)
+  assertEquals(SentryId.EMPTY_ID, chunkId)
+}
+
+fun IContinuousProfiler.testMultipleStartsAcceptedInTraceMode(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.TRACE, mocks.tracesSampler)
+  assertTrue(isRunning)
+  startProfiler(ProfileLifecycle.TRACE, mocks.tracesSampler)
+  assertTrue(isRunning)
+
+  stopProfiler(ProfileLifecycle.TRACE)
+  mocks.executor.runAll()
+  assertTrue(isRunning)
+
+  stopProfiler(ProfileLifecycle.TRACE)
+  mocks.executor.runAll()
+  assertFalse(isRunning)
+}
+
+fun IContinuousProfiler.testLogsWarningIfNotSampled(mocks: ProfilerMocks) {
+  whenever(mocks.tracesSampler.sampleSessionProfile(any())).thenReturn(false)
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertFalse(isRunning)
+  verify(mocks.logger)
+    .log(eq(SentryLevel.DEBUG), eq("Profiler was not started due to sampling decision."))
+}
+
+fun IContinuousProfiler.testEvaluatesSessionSampleRateOnlyOnce(mocks: ProfilerMocks) {
+  verify(mocks.tracesSampler, never()).sampleSessionProfile(any())
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  verify(mocks.tracesSampler, times(1)).sampleSessionProfile(any())
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  verify(mocks.tracesSampler, times(1)).sampleSessionProfile(any())
+}
+
+fun IContinuousProfiler.testReevaluateSamplingOnNextStart(mocks: ProfilerMocks) {
+  verify(mocks.tracesSampler, never()).sampleSessionProfile(any())
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  verify(mocks.tracesSampler, times(1)).sampleSessionProfile(any())
+  reevaluateSampling()
+  verify(mocks.tracesSampler, times(1)).sampleSessionProfile(any())
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  verify(mocks.tracesSampler, times(2)).sampleSessionProfile(any())
+}
+
+fun IContinuousProfiler.testStopsAndRestartsForEachChunk(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertTrue(isRunning)
+  val oldChunkId = chunkId
+
+  mocks.executor.runAll()
+  verify(mocks.logger).log(eq(SentryLevel.DEBUG), eq("Profile chunk finished. Starting a new one."))
+  assertTrue(isRunning)
+
+  mocks.executor.runAll()
+  verify(mocks.logger, times(2))
+    .log(eq(SentryLevel.DEBUG), eq("Profile chunk finished. Starting a new one."))
+  assertTrue(isRunning)
+  assertNotEquals(oldChunkId, chunkId)
+}
+
+fun IContinuousProfiler.testSendsChunkOnRestart(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertTrue(isRunning)
+  mocks.executor.runAll()
+  verify(mocks.scopes, never()).captureProfileChunk(any())
+  mocks.executor.runAll()
+  verify(mocks.scopes).captureProfileChunk(any())
+}
+
+fun IContinuousProfiler.testSendsChunkOnStop(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertTrue(isRunning)
+  mocks.executor.runAll()
+  verify(mocks.scopes, never()).captureProfileChunk(any())
+  stopProfiler(ProfileLifecycle.MANUAL)
+  mocks.executor.runAll()
+  verify(mocks.scopes).captureProfileChunk(any())
+}
+
+fun IContinuousProfiler.testCloseWithoutTerminatingStopsAfterChunk(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  startProfiler(ProfileLifecycle.TRACE, mocks.tracesSampler)
+  assertTrue(isRunning)
+  close(false)
+  assertTrue(isRunning)
+  mocks.executor.runAll()
+  assertFalse(isRunning)
+}
+
+fun IContinuousProfiler.testDoesNotSendChunksAfterClose(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertTrue(isRunning)
+  close(true)
+  mocks.executor.runAll()
+  verify(mocks.scopes, never()).captureProfileChunk(any())
+}
+
+fun IContinuousProfiler.testStopsWhenRateLimited(mocks: ProfilerMocks) {
+  val rateLimiter = mock<RateLimiter>()
+  whenever(rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi)).thenReturn(true)
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertTrue(isRunning)
+  (this as RateLimiter.IRateLimitObserver).onRateLimitChanged(rateLimiter)
+  assertFalse(isRunning)
+  assertEquals(SentryId.EMPTY_ID, profilerId)
+  assertEquals(SentryId.EMPTY_ID, chunkId)
+  verify(mocks.logger).log(eq(SentryLevel.WARNING), eq("SDK is rate limited. Stopping profiler."))
+}
+
+fun IContinuousProfiler.testDoesNotStartWhenRateLimited(mocks: ProfilerMocks) {
+  val rateLimiter = mock<RateLimiter>()
+  whenever(rateLimiter.isActiveForCategory(DataCategory.ProfileChunkUi)).thenReturn(true)
+  whenever(mocks.scopes.rateLimiter).thenReturn(rateLimiter)
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertFalse(isRunning)
+  assertEquals(SentryId.EMPTY_ID, profilerId)
+  assertEquals(SentryId.EMPTY_ID, chunkId)
+  verify(mocks.logger).log(eq(SentryLevel.WARNING), eq("SDK is rate limited. Stopping profiler."))
+}
+
+fun IContinuousProfiler.testDoesNotStartWhenOffline(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertFalse(isRunning)
+  assertEquals(SentryId.EMPTY_ID, profilerId)
+  assertEquals(SentryId.EMPTY_ID, chunkId)
+  verify(mocks.logger).log(eq(SentryLevel.WARNING), eq("Device is offline. Stopping profiler."))
+}
+
+fun IContinuousProfiler.testCanBeStartedAgainAfterStopCycle(mocks: ProfilerMocks) {
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertTrue(isRunning)
+  stopProfiler(ProfileLifecycle.MANUAL)
+  mocks.executor.runAll()
+  assertFalse(isRunning)
+
+  startProfiler(ProfileLifecycle.MANUAL, mocks.tracesSampler)
+  assertTrue(isRunning)
+  mocks.executor.runAll()
+  assertTrue(isRunning, "shouldStop must be reset on start")
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
index d0dbd1deb50..d67a869eff0 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt
@@ -1649,6 +1649,31 @@ class ManifestMetadataReaderTest {
     assertFalse(fixture.options.isEnableAppStartProfiling)
   }
 
+  @Test
+  fun `applyMetadata reads enableLegacyProfiling flag to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.ENABLE_LEGACY_PROFILING to false)
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertFalse(fixture.options.isEnableLegacyProfiling)
+  }
+
+  @Test
+  fun `applyMetadata reads enableLegacyProfiling flag to options and keeps default if not found`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertTrue(fixture.options.isEnableLegacyProfiling)
+  }
+
   @Test
   fun `applyMetadata reads enableScopePersistence flag to options`() {
     // Arrange
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
new file mode 100644
index 00000000000..2f76e73108f
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoContinuousProfilerTest.kt
@@ -0,0 +1,223 @@
+package io.sentry.android.core
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.IConnectionStatusProvider
+import io.sentry.ILogger
+import io.sentry.IScopes
+import io.sentry.ProfileLifecycle
+import io.sentry.Sentry
+import io.sentry.SentryLevel
+import io.sentry.TracesSampler
+import io.sentry.android.core.internal.util.SentryFrameMetricsCollector
+import io.sentry.test.DeferredExecutorService
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+import org.junit.runner.RunWith
+import org.mockito.Mockito.mockStatic
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.spy
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+@RunWith(AndroidJUnit4::class)
+class PerfettoContinuousProfilerTest {
+  private lateinit var context: Context
+  private val fixture = Fixture()
+  private lateinit var mocks: ProfilerMocks
+
+  private class Fixture {
+    private val mockDsn = "http://key@localhost/proj"
+    val executor = DeferredExecutorService()
+    val mockedSentry = mockStatic(Sentry::class.java)
+    val mockLogger = mock<ILogger>()
+    val mockTracesSampler = mock<TracesSampler>()
+    val mockPerfettoProfiler = mock<PerfettoProfiler>()
+    val frameMetricsCollector: SentryFrameMetricsCollector = mock()
+
+    val scopes: IScopes = mock()
+
+    val options =
+      spy(SentryAndroidOptions()).apply {
+        dsn = mockDsn
+        profilesSampleRate = 1.0
+        isDebug = true
+        setLogger(mockLogger)
+      }
+
+    val mockTraceFile =
+      java.io.File.createTempFile("test-trace", ".pftrace").apply {
+        writeBytes(byteArrayOf(0x50, 0x65, 0x72, 0x66))
+        deleteOnExit()
+      }
+
+    init {
+      whenever(mockTracesSampler.sampleSessionProfile(any())).thenReturn(true)
+      whenever(mockPerfettoProfiler.start(any())).thenReturn(true)
+      doAnswer { invocation ->
+          val listener = invocation.getArgument<java.util.function.Consumer<java.io.File?>>(0)
+          listener.accept(mockTraceFile)
+          null
+        }
+        .whenever(mockPerfettoProfiler)
+        .endAndCollect(any())
+    }
+
+    fun getSut(
+      optionConfig: ((options: SentryAndroidOptions) -> Unit) = {}
+    ): PerfettoContinuousProfiler {
+      options.executorService = executor
+      optionConfig(options)
+      whenever(scopes.options).thenReturn(options)
+      return PerfettoContinuousProfiler(
+        mockLogger,
+        frameMetricsCollector,
+        { options.executorService },
+        { mockPerfettoProfiler },
+      )
+    }
+  }
+
+  @BeforeTest
+  fun `set up`() {
+    context = ApplicationProvider.getApplicationContext()
+    Sentry.setCurrentScopes(fixture.scopes)
+    fixture.mockedSentry.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(fixture.scopes)
+    mocks =
+      ProfilerMocks(fixture.executor, fixture.mockTracesSampler, fixture.mockLogger, fixture.scopes)
+  }
+
+  @AfterTest
+  fun clear() {
+    fixture.mockedSentry.close()
+  }
+
+  // -- Shared tests (see ContinuousProfilerTestCases.kt) --
+
+  @Test
+  fun `isRunning reflects profiler status`() = fixture.getSut().testIsRunningReflectsStatus(mocks)
+
+  @Test
+  fun `stopProfiler stops the profiler after chunk is finished`() =
+    fixture.getSut().testStopProfilerStopsAfterChunkFinished(mocks)
+
+  @Test
+  fun `profiler multiple starts are accepted in trace mode`() =
+    fixture.getSut().testMultipleStartsAcceptedInTraceMode(mocks)
+
+  @Test
+  fun `profiler logs a warning on start if not sampled`() =
+    fixture.getSut().testLogsWarningIfNotSampled(mocks)
+
+  @Test
+  fun `profiler evaluates sessionSampleRate only the first time`() =
+    fixture.getSut().testEvaluatesSessionSampleRateOnlyOnce(mocks)
+
+  @Test
+  fun `when reevaluateSampling, profiler evaluates sessionSampleRate on next start`() =
+    fixture.getSut().testReevaluateSamplingOnNextStart(mocks)
+
+  @Test
+  fun `profiler ignores profilesSampleRate`() {
+    val profiler = fixture.getSut { it.profilesSampleRate = 0.0 }
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+  }
+
+  @Test
+  fun `profiler stops and restart for each chunk`() =
+    fixture.getSut().testStopsAndRestartsForEachChunk(mocks)
+
+  @Test
+  fun `profiler sends chunk on each restart`() = fixture.getSut().testSendsChunkOnRestart(mocks)
+
+  @Test fun `profiler sends another chunk on stop`() = fixture.getSut().testSendsChunkOnStop(mocks)
+
+  @Test
+  fun `close without terminating stops all profiles after chunk is finished`() =
+    fixture.getSut().testCloseWithoutTerminatingStopsAfterChunk(mocks)
+
+  @Test
+  fun `profiler does not send chunks after close`() =
+    fixture.getSut().testDoesNotSendChunksAfterClose(mocks)
+
+  @Test fun `profiler stops when rate limited`() = fixture.getSut().testStopsWhenRateLimited(mocks)
+
+  @Test
+  fun `profiler does not start when rate limited`() =
+    fixture.getSut().testDoesNotStartWhenRateLimited(mocks)
+
+  @Test
+  fun `profiler does not start when offline`() =
+    fixture
+      .getSut {
+        it.connectionStatusProvider = mock { provider ->
+          whenever(provider.connectionStatus)
+            .thenReturn(IConnectionStatusProvider.ConnectionStatus.DISCONNECTED)
+        }
+      }
+      .testDoesNotStartWhenOffline(mocks)
+
+  @Test
+  fun `manual profiler can be started again after a full start-stop cycle`() =
+    fixture.getSut().testCanBeStartedAgainAfterStopCycle(mocks)
+
+  // -- Perfetto-specific tests --
+
+  @Test
+  fun `async chunk callback does not restart when stop requested while pending`() {
+    val profiler = fixture.getSut()
+
+    // Defer the endAndCollect listener to simulate the OS delivering the trace asynchronously,
+    // after the chunk timer already captured the (then-true) restart decision.
+    var pendingListener: java.util.function.Consumer<java.io.File?>? = null
+    doAnswer { invocation ->
+        pendingListener = invocation.getArgument(0)
+        null
+      }
+      .whenever(fixture.mockPerfettoProfiler)
+      .endAndCollect(any())
+
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+
+    // Chunk timer fires: stopInternal(true) captures shouldRestart=true and calls endAndCollect,
+    // but the listener is held pending instead of firing inline.
+    fixture.executor.runAll()
+    assertFalse(profiler.isRunning)
+    assertNotNull(pendingListener)
+
+    // A stop is requested while the async callback is still pending.
+    profiler.stopProfiler(ProfileLifecycle.MANUAL)
+
+    // The OS now delivers the trace. The callback must honor the late stop and not restart.
+    pendingListener!!.accept(fixture.mockTraceFile)
+    fixture.executor.runAll()
+    assertFalse(
+      profiler.isRunning,
+      "profiler must not restart when a stop was requested while the callback was pending",
+    )
+  }
+
+  @Test
+  fun `profiler multiple starts are ignored in manual mode`() {
+    val profiler = fixture.getSut()
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+    profiler.startProfiler(ProfileLifecycle.MANUAL, fixture.mockTracesSampler)
+    assertTrue(profiler.isRunning)
+    verify(fixture.mockLogger)
+      .log(
+        eq(SentryLevel.WARNING),
+        eq("Unexpected call to startProfiler(MANUAL) while profiler already running. Skipping."),
+      )
+  }
+}
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoProfilerTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoProfilerTest.kt
new file mode 100644
index 00000000000..0746d36dfff
--- /dev/null
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/PerfettoProfilerTest.kt
@@ -0,0 +1,268 @@
+package io.sentry.android.core
+
+import android.content.Context
+import android.os.ProfilingManager
+import android.os.ProfilingResult
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.sentry.ILogger
+import io.sentry.test.DeferredExecutorService
+import java.io.File
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicReference
+import java.util.function.Consumer
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import org.junit.runner.RunWith
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doAnswer
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+import org.robolectric.annotation.Config
+
+@RunWith(AndroidJUnit4::class)
+@Config(sdk = [35])
+class PerfettoProfilerTest {
+
+  private lateinit var context: Context
+  private val mockLogger = mock<ILogger>()
+  private val executor = DeferredExecutorService()
+
+  private lateinit var capturedCallback: Consumer<ProfilingResult>
+
+  private val mockProfilingManager =
+    mock<ProfilingManager>().also { manager ->
+      doAnswer { invocation ->
+          @Suppress("UNCHECKED_CAST")
+          capturedCallback = invocation.getArgument(5) as Consumer<ProfilingResult>
+          null
+        }
+        .whenever(manager)
+        .requestProfiling(any(), any(), any(), any(), any(), any())
+    }
+
+  @BeforeTest
+  fun setUp() {
+    context = ApplicationProvider.getApplicationContext()
+  }
+
+  private fun getSut(profilingManager: ProfilingManager? = mockProfilingManager): PerfettoProfiler {
+    return PerfettoProfiler(mockLogger, executor, profilingManager)
+  }
+
+  private fun createTraceFile(): File {
+    return File.createTempFile("test-trace", ".pftrace").apply {
+      writeBytes(byteArrayOf(0x50, 0x65, 0x72, 0x66))
+      deleteOnExit()
+    }
+  }
+
+  private fun mockResult(
+    errorCode: Int = ProfilingResult.ERROR_NONE,
+    filePath: String? = null,
+    errorMessage: String? = null,
+  ): ProfilingResult {
+    return mock<ProfilingResult>().also {
+      whenever(it.errorCode).thenReturn(errorCode)
+      whenever(it.resultFilePath).thenReturn(filePath)
+      whenever(it.errorMessage).thenReturn(errorMessage)
+    }
+  }
+
+  @Test
+  fun `start returns true on first call`() {
+    val profiler = getSut()
+    assertTrue(profiler.start(60000))
+  }
+
+  @Test
+  fun `start returns false when already started`() {
+    val profiler = getSut()
+    assertTrue(profiler.start(60000))
+    assertFalse(profiler.start(60000))
+  }
+
+  @Test
+  fun `start returns false when ProfilingManager is null`() {
+    val profiler = getSut(profilingManager = null)
+    assertFalse(profiler.start(60000))
+  }
+
+  @Test
+  fun `endAndCollect calls listener with null when never started`() {
+    val profiler = getSut()
+    val result = AtomicReference<File?>(File("sentinel"))
+    profiler.endAndCollect { result.set(it) }
+    assertNull(result.get())
+  }
+
+  @Test
+  fun `endAndCollect calls listener synchronously when result already available`() {
+    val traceFile = createTraceFile()
+    val profiler = getSut()
+    profiler.start(60000)
+
+    capturedCallback.accept(mockResult(filePath = traceFile.absolutePath))
+
+    val result = AtomicReference<File?>()
+    profiler.endAndCollect { result.set(it) }
+
+    assertEquals(traceFile.absolutePath, result.get()?.absolutePath)
+  }
+
+  @Test
+  fun `endAndCollect calls listener when result arrives later`() {
+    val traceFile = createTraceFile()
+    val profiler = getSut()
+    profiler.start(60000)
+
+    val result = AtomicReference<File?>()
+    profiler.endAndCollect { result.set(it) }
+
+    assertNull(result.get())
+
+    capturedCallback.accept(mockResult(filePath = traceFile.absolutePath))
+
+    assertEquals(traceFile.absolutePath, result.get()?.absolutePath)
+  }
+
+  @Test
+  fun `endAndCollect calls listener with null on error result`() {
+    val profiler = getSut()
+    profiler.start(60000)
+
+    val result = AtomicReference<File?>(File("sentinel"))
+
+    capturedCallback.accept(
+      mockResult(errorCode = ProfilingResult.ERROR_UNKNOWN, errorMessage = "unknown error")
+    )
+    profiler.endAndCollect { result.set(it) }
+
+    assertNull(result.get())
+  }
+
+  @Test
+  fun `endAndCollect calls listener with null on rate limit error`() {
+    val profiler = getSut()
+    profiler.start(60000)
+
+    val result = AtomicReference<File?>(File("sentinel"))
+
+    capturedCallback.accept(mockResult(errorCode = ProfilingResult.ERROR_FAILED_RATE_LIMIT_PROCESS))
+    profiler.endAndCollect { result.set(it) }
+
+    assertNull(result.get())
+  }
+
+  @Test
+  fun `timeout fires listener with null when OS never responds`() {
+    val profiler = getSut()
+    profiler.start(60000)
+
+    val result = AtomicReference<File?>(File("sentinel"))
+    profiler.endAndCollect { result.set(it) }
+
+    assertEquals("sentinel", result.get()?.name)
+
+    executor.runAll()
+
+    assertNull(result.get())
+  }
+
+  @Test
+  fun `timeout is no-op when result already arrived`() {
+    val traceFile = createTraceFile()
+    val profiler = getSut()
+    profiler.start(60000)
+
+    val callCount = AtomicInteger(0)
+    val result = AtomicReference<File?>()
+    profiler.endAndCollect {
+      callCount.incrementAndGet()
+      result.set(it)
+    }
+
+    capturedCallback.accept(mockResult(filePath = traceFile.absolutePath))
+
+    assertEquals(1, callCount.get())
+    assertEquals(traceFile.absolutePath, result.get()?.absolutePath)
+
+    executor.runAll()
+
+    assertEquals(1, callCount.get())
+  }
+
+  @Test
+  fun `listener is called exactly once when result and endAndCollect race`() {
+    val traceFile = createTraceFile()
+    val profiler = getSut()
+    profiler.start(60000)
+
+    val callCount = AtomicInteger(0)
+    val latch = CountDownLatch(1)
+
+    val resultThread = Thread {
+      capturedCallback.accept(mockResult(filePath = traceFile.absolutePath))
+      latch.countDown()
+    }
+
+    profiler.endAndCollect { callCount.incrementAndGet() }
+    resultThread.start()
+
+    assertTrue(latch.await(5, TimeUnit.SECONDS))
+
+    executor.runAll()
+
+    assertEquals(1, callCount.get())
+  }
+
+  @Test
+  fun `trace file is deleted when result arrives after the timeout`() {
+    val traceFile = createTraceFile()
+    val profiler = getSut()
+    profiler.start(60000)
+
+    val callCount = AtomicInteger(0)
+    profiler.endAndCollect { callCount.incrementAndGet() }
+
+    executor.runAll()
+    assertEquals(1, callCount.get())
+
+    capturedCallback.accept(mockResult(filePath = traceFile.absolutePath))
+
+    assertEquals(1, callCount.get())
+    assertFalse(traceFile.exists())
+  }
+
+  @Test
+  fun `endAndCollect calls listener with null when result file path is null`() {
+    val profiler = getSut()
+    profiler.start(60000)
+
+    val result = AtomicReference<File?>(File("sentinel"))
+
+    capturedCallback.accept(mockResult(filePath = null))
+    profiler.endAndCollect { result.set(it) }
+
+    assertNull(result.get())
+  }
+
+  @Test
+  fun `endAndCollect calls listener with null when trace file does not exist`() {
+    val profiler = getSut()
+    profiler.start(60000)
+
+    val result = AtomicReference<File?>(File("sentinel"))
+
+    capturedCallback.accept(mockResult(filePath = "/non/existent/path.pftrace"))
+    profiler.endAndCollect { result.set(it) }
+
+    assertNull(result.get())
+  }
+}
diff --git a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
index 79150b51c98..ac53c538de5 100644
--- a/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
+++ b/sentry-samples/sentry-samples-android/src/main/AndroidManifest.xml
@@ -90,7 +90,8 @@
 
     <activity
       android:name=".ProfilingActivity"
-      android:exported="false" />
+      android:exported="false"
+      android:theme="@style/AppTheme.Main" />
 
     <activity
       android:name=".CustomTabsActivity"
@@ -199,7 +200,7 @@
     <!-- Enable profiling on app start -->
     <meta-data
       android:name="io.sentry.traces.profiling.start-on-app-start"
-      android:value="true" />
+      android:value="false" />
 
     <!--    how to disable the Activity auto instrumentation for tracing-->
     <!--    <meta-data android:name="io.sentry.traces.activity.enable" android:value="false" />-->
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt
index 8626c12c6c8..e24822b3e42 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingActivity.kt
@@ -1,161 +1,108 @@
 package io.sentry.samples.android
 
+import android.os.Build
 import android.os.Bundle
-import android.view.View
-import android.widget.SeekBar
 import android.widget.Toast
-import androidx.activity.OnBackPressedCallback
-import androidx.appcompat.app.AppCompatActivity
-import androidx.recyclerview.widget.LinearLayoutManager
-import io.sentry.ITransaction
-import io.sentry.ProfilingTraceData
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
 import io.sentry.Sentry
-import io.sentry.SentryEnvelopeItem
-import io.sentry.samples.android.databinding.ActivityProfilingBinding
-import java.io.ByteArrayOutputStream
-import java.io.File
-import java.util.UUID
 import java.util.concurrent.Executors
-import java.util.zip.GZIPOutputStream
 
-class ProfilingActivity : AppCompatActivity() {
-  private lateinit var binding: ActivityProfilingBinding
+class ProfilingActivity : ComponentActivity() {
+
   private val executors = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())
   private var profileFinished = true
 
   override fun onCreate(savedInstanceState: Bundle?) {
     super.onCreate(savedInstanceState)
-
-    onBackPressedDispatcher.addCallback(
-      this,
-      object : OnBackPressedCallback(true) {
-        override fun handleOnBackPressed() {
-          if (profileFinished) {
-            isEnabled = false
-            onBackPressedDispatcher.onBackPressed()
-          } else {
-            Toast.makeText(this@ProfilingActivity, R.string.profiling_running, Toast.LENGTH_SHORT)
-              .show()
-          }
-        }
-      },
-    )
-    binding = ActivityProfilingBinding.inflate(layoutInflater)
-
-    binding.profilingDurationSeekbar.setOnSeekBarChangeListener(
-      object : SeekBar.OnSeekBarChangeListener {
-        override fun onProgressChanged(p0: SeekBar, p1: Int, p2: Boolean) {
-          binding.profilingDurationText.text =
-            getString(R.string.profiling_duration, getProfileDuration())
-        }
-
-        override fun onStartTrackingTouch(p0: SeekBar) {}
-
-        override fun onStopTrackingTouch(p0: SeekBar) {}
-      }
-    )
-    binding.profilingDurationText.text =
-      getString(R.string.profiling_duration, getProfileDuration())
-
-    binding.profilingThreadsSeekbar.setOnSeekBarChangeListener(
-      object : SeekBar.OnSeekBarChangeListener {
-        override fun onProgressChanged(p0: SeekBar, p1: Int, p2: Boolean) {
-          binding.profilingThreadsText.text =
-            getString(R.string.profiling_threads, getBackgroundThreads())
-        }
-
-        override fun onStartTrackingTouch(p0: SeekBar) {}
-
-        override fun onStopTrackingTouch(p0: SeekBar) {}
-      }
-    )
-    binding.profilingThreadsSeekbar.max = Runtime.getRuntime().availableProcessors() - 1
-    binding.profilingThreadsText.text =
-      getString(R.string.profiling_threads, getBackgroundThreads())
-
-    binding.profilingList.adapter = ProfilingListAdapter()
-    binding.profilingList.layoutManager = LinearLayoutManager(this)
-
-    binding.profilingStart.setOnClickListener {
-      binding.profilingProgressBar.visibility = View.VISIBLE
-      profileFinished = false
-      val seconds = getProfileDuration()
-      val threads = getBackgroundThreads()
-      val t = Sentry.startTransaction("Profiling Test", "$seconds s - $threads threads")
-      repeat(threads) { executors.submit { runMathOperations() } }
-      executors.submit { swipeList() }
-
-      Thread {
-          Thread.sleep((seconds * 1000).toLong())
-          finishTransactionAndPrintResults(t)
-          binding.root.post { binding.profilingProgressBar.visibility = View.GONE }
-        }
-        .start()
-    }
-    setContentView(binding.root)
-    Sentry.reportFullyDisplayed()
+    setContent { MaterialTheme { ProfilingScreen() } }
   }
 
-  private fun finishTransactionAndPrintResults(t: ITransaction) {
-    t.finish()
-    profileFinished = true
-    val profilesDirPath = Sentry.getCurrentScopes().options.profilingTracesDirPath
-    if (profilesDirPath == null) {
-      Toast.makeText(this, R.string.profiling_no_dir_set, Toast.LENGTH_SHORT).show()
-      return
-    }
-
-    // We have concurrent profiling now. We have to wait for all transactions to finish (e.g. button
-    // click)
-    //  before reading the profile, otherwise it's empty and a crash occurs
-    if (Sentry.getSpan() != null) {
-      val timeout = Sentry.getCurrentScopes().options.idleTimeout ?: 0
-      val duration = (getProfileDuration() * 1000).toLong()
-      Thread.sleep((timeout - duration).coerceAtLeast(0))
-    }
-
-    try {
-      // Get the last trace file, which is the current profile
-      val origProfileFile = File(profilesDirPath).listFiles()?.maxByOrNull { f -> f.lastModified() }
-      // Create a new profile file and copy the content of the original file into it
-      val profile = File(cacheDir, UUID.randomUUID().toString())
-      origProfileFile?.copyTo(profile)
-
-      val profileLength = profile.length()
-      val traceData = ProfilingTraceData(profile, t)
-      // Create envelope item from copied profile
-      val item =
-        SentryEnvelopeItem.fromProfilingTrace(
-          traceData,
-          Long.MAX_VALUE,
-          Sentry.getCurrentScopes().options.serializer,
-        )
-      val itemData = item.data
-
-      // Compress the envelope item using Gzip
-      val bos = ByteArrayOutputStream()
-      GZIPOutputStream(bos).bufferedWriter().use { it.write(String(itemData)) }
-
-      binding.root.post {
-        binding.profilingResult.text =
-          getString(R.string.profiling_result, profileLength, itemData.size, bos.toByteArray().size)
+  @OptIn(ExperimentalMaterial3Api::class)
+  @Composable
+  private fun ProfilingScreen() {
+    val context = LocalContext.current
+    val options = remember { Sentry.getCurrentScopes().options }
+    val isPerfetto = remember { Build.VERSION.SDK_INT >= 35 }
+    val isContinuousEnabled = remember { options.isContinuousProfilingEnabled }
+
+    var showProgress by remember { mutableStateOf(false) }
+    var manualActive by remember { mutableStateOf(false) }
+
+    val statusText =
+      when {
+        !isContinuousEnabled -> stringResource(R.string.profiling_status_none)
+        isPerfetto -> stringResource(R.string.profiling_status_perfetto)
+        else -> stringResource(R.string.profiling_status_legacy)
       }
-    } catch (e: Exception) {
-      e.printStackTrace()
-    }
-  }
 
-  private fun swipeList() {
-    while (!profileFinished) {
-      if (
-        (binding.profilingList.layoutManager as? LinearLayoutManager)
-          ?.findFirstVisibleItemPosition() == 0
+    Scaffold(topBar = { TopAppBar(title = { Text("Profiling") }) }) { innerPadding ->
+      Column(
+        modifier = Modifier.fillMaxSize().padding(innerPadding).padding(16.dp),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
       ) {
-        binding.profilingList.smoothScrollToPosition(100)
-      } else {
-        binding.profilingList.smoothScrollToPosition(0)
+        Text(text = statusText, fontWeight = FontWeight.Bold)
+
+        Text("profiling.enable-legacy-profiling: ${options.isEnableLegacyProfiling}")
+        Text("Build.VERSION.SDK_INT: ${Build.VERSION.SDK_INT}")
+        Text("traces.profiling.session-sample-rate: ${options.profileSessionSampleRate}")
+
+        HorizontalDivider(modifier = Modifier.padding(vertical = 4.dp))
+
+        Button(
+          onClick = {
+            if (!manualActive) {
+              Sentry.startProfiler()
+              manualActive = true
+              profileFinished = false
+              showProgress = true
+
+              val threads = 2
+              repeat(threads) { executors.submit { runMathOperations() } }
+
+              Toast.makeText(context, R.string.profiling_manual_started, Toast.LENGTH_SHORT).show()
+            } else {
+              Sentry.stopProfiler()
+              manualActive = false
+              profileFinished = true
+              showProgress = false
+
+              Toast.makeText(context, R.string.profiling_manual_stopped, Toast.LENGTH_SHORT).show()
+            }
+          }
+        ) {
+          Text(
+            if (manualActive) stringResource(R.string.profiling_stop_manual)
+            else stringResource(R.string.profiling_start_manual)
+          )
+        }
+
+        if (showProgress) {
+          CircularProgressIndicator()
+        }
       }
-      Thread.sleep(3000)
     }
   }
 
@@ -167,21 +114,8 @@ class ProfilingActivity : AppCompatActivity() {
 
   private fun fibonacci(n: Int): Int =
     when {
-      profileFinished -> n // If we destroy the activity we stop this function
+      profileFinished -> n
       n <= 1 -> 1
       else -> fibonacci(n - 1) + fibonacci(n - 2)
     }
-
-  private fun getProfileDuration(): Float {
-    // Minimum duration of the profile is 100 milliseconds
-    return binding.profilingDurationSeekbar.progress / 10.0F + 0.1F
-  }
-
-  private fun getBackgroundThreads(): Int {
-    // Minimum duration of the profile is 100 milliseconds
-    return binding.profilingThreadsSeekbar.progress.coerceIn(
-      0,
-      Runtime.getRuntime().availableProcessors() - 1,
-    )
-  }
 }
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingListAdapter.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingListAdapter.kt
deleted file mode 100644
index bf025118c80..00000000000
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/ProfilingListAdapter.kt
+++ /dev/null
@@ -1,41 +0,0 @@
-package io.sentry.samples.android
-
-import android.graphics.Bitmap
-import android.graphics.Color
-import android.view.LayoutInflater
-import android.view.ViewGroup
-import android.widget.ImageView
-import androidx.recyclerview.widget.RecyclerView
-import io.sentry.samples.android.databinding.ProfilingItemListBinding
-import kotlin.random.Random
-
-class ProfilingListAdapter : RecyclerView.Adapter<ViewHolder>() {
-  override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
-    val binding =
-      ProfilingItemListBinding.inflate(LayoutInflater.from(parent.context), parent, false)
-    return ViewHolder(binding)
-  }
-
-  override fun onBindViewHolder(holder: ViewHolder, position: Int) {
-    holder.imageView.setImageBitmap(generateBitmap())
-  }
-
-  @Suppress("MagicNumber")
-  private fun generateBitmap(): Bitmap {
-    val bitmapSize = 128
-    val colors =
-      (0 until (bitmapSize * bitmapSize))
-        .map { Color.rgb(Random.nextInt(256), Random.nextInt(256), Random.nextInt(256)) }
-        .toIntArray()
-    return Bitmap.createBitmap(colors, bitmapSize, bitmapSize, Bitmap.Config.ARGB_8888)
-  }
-
-  // Disables view recycling.
-  override fun getItemViewType(position: Int): Int = position
-
-  override fun getItemCount(): Int = 200
-}
-
-class ViewHolder(binding: ProfilingItemListBinding) : RecyclerView.ViewHolder(binding.root) {
-  val imageView: ImageView = binding.benchmarkItemListImage
-}
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml
deleted file mode 100644
index 8100834f78b..00000000000
--- a/sentry-samples/sentry-samples-android/src/main/res/layout/activity_profiling.xml
+++ /dev/null
@@ -1,59 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  xmlns:tools="http://schemas.android.com/tools"
-  android:orientation="vertical"
-  android:layout_width="match_parent"
-  android:layout_height="match_parent">
-
-  <TextView
-    android:id="@+id/profiling_duration_text"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:gravity="center"
-    android:text="@string/profiling_duration" />
-
-  <SeekBar
-    android:id="@+id/profiling_duration_seekbar"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:max="300" />
-
-  <TextView
-    android:id="@+id/profiling_threads_text"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:gravity="center"
-    android:text="@string/profiling_threads" />
-
-  <SeekBar
-    android:id="@+id/profiling_threads_seekbar"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:max="4" />
-
-  <TextView
-    android:id="@+id/profiling_result"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:gravity="center"
-    android:text="@string/profiling_result" />
-
-  <Button
-    android:id="@+id/profiling_start"
-    android:layout_width="wrap_content"
-    android:layout_height="wrap_content"
-    android:text="@string/profiling_start" />
-
-  <ProgressBar
-    android:id="@+id/profiling_progress_bar"
-    android:layout_width="wrap_content"
-    android:layout_height="wrap_content"
-    android:visibility="gone" />
-
-  <androidx.recyclerview.widget.RecyclerView
-    android:id="@+id/profiling_list"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:listitem="@layout/profiling_item_list" />
-
-</LinearLayout>
diff --git a/sentry-samples/sentry-samples-android/src/main/res/layout/profiling_item_list.xml b/sentry-samples/sentry-samples-android/src/main/res/layout/profiling_item_list.xml
deleted file mode 100644
index b5d7e776259..00000000000
--- a/sentry-samples/sentry-samples-android/src/main/res/layout/profiling_item_list.xml
+++ /dev/null
@@ -1,15 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-  xmlns:tools="http://schemas.android.com/tools"
-  android:layout_width="match_parent"
-  android:layout_height="wrap_content">
-
-  <ImageView
-    android:id="@+id/benchmark_item_list_image"
-    android:layout_width="match_parent"
-    android:layout_height="wrap_content"
-    android:scaleType="centerCrop"
-    android:layout_margin="8dp"
-    tools:src="@android:color/darker_gray" />
-
-</LinearLayout>
diff --git a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
index 2f42a4bff1d..edd346b621c 100644
--- a/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
+++ b/sentry-samples/sentry-samples-android/src/main/res/values/strings.xml
@@ -46,12 +46,13 @@ Nulla interdum gravida augue, vel fringilla lorem bibendum vel. In hac habitasse
   </string>
   <string name="camera_permission">Camera Permission</string>
   <string name="write_permission">Write External Storage Permission</string>
-  <string name="profiling_duration">Duration of profile %.1f seconds</string>
-  <string name="profiling_threads">Background threads to use: %d</string>
-  <string name="profiling_running">Profiling is running</string>
-  <string name="profiling_no_dir_set">No profiling dir path set</string>
-  <string name="profiling_start">Start Profiling</string>
-  <string name="profiling_result">Profile trace file size = %d bytes \nItem payload size = %d bytes \nData sent to Sentry size = %d bytes</string>
+  <string name="profiling_start_manual">Start (Manual)</string>
+  <string name="profiling_stop_manual">Stop (Manual)</string>
+  <string name="profiling_status_perfetto">Active Profiler: Perfetto (ProfilingManager)</string>
+  <string name="profiling_status_legacy">Active Profiler: Legacy (simpleperf)</string>
+  <string name="profiling_status_none">Active Profiler: None (disabled)</string>
+  <string name="profiling_manual_started">Manual profiler started</string>
+  <string name="profiling_manual_stopped">Manual profiler stopped — chunk sent to Sentry</string>
   <string name="open_camera_activity">Open Camera Activity</string>
   <string name="open_http_request_activity">Open Trigger HTTP Request Activity</string>
   <string name="trigger_okhttp_request">Trigger OkHttp Request</string>
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 14780d1a4b2..7e258b0d4b1 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -2104,6 +2104,7 @@ public final class io/sentry/PerformanceCollectionData {
 }
 
 public final class io/sentry/ProfileChunk : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
+	public static final field CONTENT_TYPE_PERFETTO Ljava/lang/String;
 	public static final field PLATFORM_ANDROID Ljava/lang/String;
 	public static final field PLATFORM_JAVA Ljava/lang/String;
 	public fun <init> ()V
@@ -2111,6 +2112,7 @@ public final class io/sentry/ProfileChunk : io/sentry/JsonSerializable, io/sentr
 	public fun equals (Ljava/lang/Object;)Z
 	public fun getChunkId ()Lio/sentry/protocol/SentryId;
 	public fun getClientSdk ()Lio/sentry/protocol/SdkVersion;
+	public fun getContentType ()Ljava/lang/String;
 	public fun getDebugMeta ()Lio/sentry/protocol/DebugMeta;
 	public fun getEnvironment ()Ljava/lang/String;
 	public fun getMeasurements ()Ljava/util/Map;
@@ -2134,6 +2136,7 @@ public final class io/sentry/ProfileChunk : io/sentry/JsonSerializable, io/sentr
 public final class io/sentry/ProfileChunk$Builder {
 	public fun <init> (Lio/sentry/protocol/SentryId;Lio/sentry/protocol/SentryId;Ljava/util/Map;Ljava/io/File;Lio/sentry/SentryDate;Ljava/lang/String;)V
 	public fun build (Lio/sentry/SentryOptions;)Lio/sentry/ProfileChunk;
+	public fun setContentType (Ljava/lang/String;)Lio/sentry/ProfileChunk$Builder;
 }
 
 public final class io/sentry/ProfileChunk$Deserializer : io/sentry/JsonDeserializer {
@@ -2145,6 +2148,7 @@ public final class io/sentry/ProfileChunk$Deserializer : io/sentry/JsonDeseriali
 public final class io/sentry/ProfileChunk$JsonKeys {
 	public static final field CHUNK_ID Ljava/lang/String;
 	public static final field CLIENT_SDK Ljava/lang/String;
+	public static final field CONTENT_TYPE Ljava/lang/String;
 	public static final field DEBUG_META Ljava/lang/String;
 	public static final field ENVIRONMENT Ljava/lang/String;
 	public static final field MEASUREMENTS Ljava/lang/String;
@@ -2848,6 +2852,7 @@ public final class io/sentry/SentryAppStartProfilingOptions : io/sentry/JsonSeri
 	public fun isContinuousProfileSampled ()Z
 	public fun isContinuousProfilingEnabled ()Z
 	public fun isEnableAppStartProfiling ()Z
+	public fun isEnableLegacyProfiling ()Z
 	public fun isProfileSampled ()Z
 	public fun isProfilingEnabled ()Z
 	public fun isStartProfilerOnAppStart ()Z
@@ -2856,6 +2861,7 @@ public final class io/sentry/SentryAppStartProfilingOptions : io/sentry/JsonSeri
 	public fun setContinuousProfileSampled (Z)V
 	public fun setContinuousProfilingEnabled (Z)V
 	public fun setEnableAppStartProfiling (Z)V
+	public fun setEnableLegacyProfiling (Z)V
 	public fun setProfileLifecycle (Lio/sentry/ProfileLifecycle;)V
 	public fun setProfileSampleRate (Ljava/lang/Double;)V
 	public fun setProfileSampled (Z)V
@@ -2876,6 +2882,7 @@ public final class io/sentry/SentryAppStartProfilingOptions$Deserializer : io/se
 
 public final class io/sentry/SentryAppStartProfilingOptions$JsonKeys {
 	public static final field CONTINUOUS_PROFILE_SAMPLED Ljava/lang/String;
+	public static final field ENABLE_LEGACY_PROFILING Ljava/lang/String;
 	public static final field IS_CONTINUOUS_PROFILING_ENABLED Ljava/lang/String;
 	public static final field IS_ENABLE_APP_START_PROFILING Ljava/lang/String;
 	public static final field IS_PROFILING_ENABLED Ljava/lang/String;
@@ -3092,6 +3099,7 @@ public final class io/sentry/SentryEnvelopeItem {
 	public static fun fromEvent (Lio/sentry/ISerializer;Lio/sentry/SentryBaseEvent;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromLogs (Lio/sentry/ISerializer;Lio/sentry/SentryLogEvents;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromMetrics (Lio/sentry/ISerializer;Lio/sentry/SentryMetricsEvents;)Lio/sentry/SentryEnvelopeItem;
+	public static fun fromPerfettoProfileChunk (Lio/sentry/ProfileChunk;Lio/sentry/ISerializer;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromProfileChunk (Lio/sentry/ProfileChunk;Lio/sentry/ISerializer;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromProfileChunk (Lio/sentry/ProfileChunk;Lio/sentry/ISerializer;Lio/sentry/IProfileConverter;)Lio/sentry/SentryEnvelopeItem;
 	public static fun fromProfilingTrace (Lio/sentry/ProfilingTraceData;JLio/sentry/ISerializer;)Lio/sentry/SentryEnvelopeItem;
@@ -3132,6 +3140,7 @@ public final class io/sentry/SentryEnvelopeItemHeader$JsonKeys {
 	public static final field FILENAME Ljava/lang/String;
 	public static final field ITEM_COUNT Ljava/lang/String;
 	public static final field LENGTH Ljava/lang/String;
+	public static final field META_LENGTH Ljava/lang/String;
 	public static final field PLATFORM Ljava/lang/String;
 	public static final field TYPE Ljava/lang/String;
 	public fun <init> ()V
@@ -3744,6 +3753,7 @@ public class io/sentry/SentryOptions {
 	public fun isEnableDeduplication ()Z
 	public fun isEnableEventSizeLimiting ()Z
 	public fun isEnableExternalConfiguration ()Z
+	public fun isEnableLegacyProfiling ()Z
 	public fun isEnablePrettySerializationOutput ()Z
 	public fun isEnableQueueTracing ()Z
 	public fun isEnableScopePersistence ()Z
@@ -3806,6 +3816,7 @@ public class io/sentry/SentryOptions {
 	public fun setEnableDeduplication (Z)V
 	public fun setEnableEventSizeLimiting (Z)V
 	public fun setEnableExternalConfiguration (Z)V
+	public fun setEnableLegacyProfiling (Z)V
 	public fun setEnablePrettySerializationOutput (Z)V
 	public fun setEnableQueueTracing (Z)V
 	public fun setEnableScopePersistence (Z)V
diff --git a/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java b/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java
index 4736ab8fac5..22b8bb839b6 100644
--- a/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java
+++ b/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java
@@ -227,7 +227,11 @@ private CompositeData(final @Nullable ITransaction transaction) {
      * @return true if data collection timed out (for transactions only).
      */
     boolean addDataAndCheckTimeout(final @NotNull PerformanceCollectionData data) {
-      dataList.add(data);
+      // stop() hands dataList out while this timer thread may still be writing to it, so consumers
+      // synchronize on the list while iterating. We must hold the same monitor here.
+      synchronized (dataList) {
+        dataList.add(data);
+      }
       return transaction != null
           && options.getDateProvider().now().nanoTimestamp()
               > startTimestamp
diff --git a/sentry/src/main/java/io/sentry/ProfileChunk.java b/sentry/src/main/java/io/sentry/ProfileChunk.java
index 1d159030c1d..13b40784144 100644
--- a/sentry/src/main/java/io/sentry/ProfileChunk.java
+++ b/sentry/src/main/java/io/sentry/ProfileChunk.java
@@ -22,6 +22,7 @@
 public final class ProfileChunk implements JsonUnknown, JsonSerializable {
   public static final String PLATFORM_ANDROID = "android";
   public static final String PLATFORM_JAVA = "java";
+  public static final String CONTENT_TYPE_PERFETTO = "application/x-perfetto-trace";
 
   private @Nullable DebugMeta debugMeta;
   private @NotNull SentryId profilerId;
@@ -34,6 +35,8 @@ public final class ProfileChunk implements JsonUnknown, JsonSerializable {
   private @NotNull String version;
   private double timestamp;
 
+  private @Nullable String contentType;
+
   private final @Nullable File traceFile;
 
   /** Profile trace encoded with Base64. */
@@ -131,6 +134,10 @@ public double getTimestamp() {
     return version;
   }
 
+  public @Nullable String getContentType() {
+    return contentType;
+  }
+
   public @Nullable SentryProfile getSentryProfile() {
     return sentryProfile;
   }
@@ -181,8 +188,8 @@ public static final class Builder {
     private final @NotNull Map<String, ProfileMeasurement> measurements;
     private final @NotNull File traceFile;
     private final double timestamp;
-
     private final @NotNull String platform;
+    private @Nullable String contentType;
 
     public Builder(
         final @NotNull SentryId profilerId,
@@ -199,9 +206,17 @@ public Builder(
       this.platform = platform;
     }
 
+    public Builder setContentType(final @Nullable String contentType) {
+      this.contentType = contentType;
+      return this;
+    }
+
     public ProfileChunk build(SentryOptions options) {
-      return new ProfileChunk(
-          profilerId, chunkId, traceFile, measurements, timestamp, platform, options);
+      final ProfileChunk chunk =
+          new ProfileChunk(
+              profilerId, chunkId, traceFile, measurements, timestamp, platform, options);
+      chunk.contentType = contentType;
+      return chunk;
     }
   }
 
@@ -220,6 +235,7 @@ public static final class JsonKeys {
     public static final String SAMPLED_PROFILE = "sampled_profile";
     public static final String TIMESTAMP = "timestamp";
     public static final String SENTRY_PROFILE = "profile";
+    public static final String CONTENT_TYPE = "content_type";
   }
 
   @Override
@@ -248,6 +264,9 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
       writer.name(JsonKeys.ENVIRONMENT).value(logger, environment);
     }
     writer.name(JsonKeys.VERSION).value(logger, version);
+    if (contentType != null) {
+      writer.name(JsonKeys.CONTENT_TYPE).value(logger, contentType);
+    }
     if (sampledProfile != null) {
       writer.name(JsonKeys.SAMPLED_PROFILE).value(logger, sampledProfile);
     }
@@ -354,6 +373,12 @@ public static final class Deserializer implements JsonDeserializer<ProfileChunk>
               data.timestamp = timestamp;
             }
             break;
+          case JsonKeys.CONTENT_TYPE:
+            String contentType = reader.nextStringOrNull();
+            if (contentType != null) {
+              data.contentType = contentType;
+            }
+            break;
           case JsonKeys.SENTRY_PROFILE:
             SentryProfile sentryProfile =
                 reader.nextOrNull(logger, new SentryProfile.Deserializer());
diff --git a/sentry/src/main/java/io/sentry/SentryAppStartProfilingOptions.java b/sentry/src/main/java/io/sentry/SentryAppStartProfilingOptions.java
index ccacccf9c0b..a59591fdab3 100644
--- a/sentry/src/main/java/io/sentry/SentryAppStartProfilingOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryAppStartProfilingOptions.java
@@ -24,6 +24,7 @@ public final class SentryAppStartProfilingOptions implements JsonUnknown, JsonSe
   boolean continuousProfileSampled;
   boolean isEnableAppStartProfiling;
   boolean isStartProfilerOnAppStart;
+  boolean enableLegacyProfiling;
   @NotNull ProfileLifecycle profileLifecycle;
 
   private @Nullable Map<String, Object> unknown;
@@ -42,6 +43,7 @@ public SentryAppStartProfilingOptions() {
     profilingTracesHz = 0;
     isEnableAppStartProfiling = true;
     isStartProfilerOnAppStart = false;
+    enableLegacyProfiling = true;
   }
 
   SentryAppStartProfilingOptions(
@@ -62,6 +64,7 @@ public SentryAppStartProfilingOptions() {
     profilingTracesHz = options.getProfilingTracesHz();
     isEnableAppStartProfiling = options.isEnableAppStartProfiling();
     isStartProfilerOnAppStart = options.isStartProfilerOnAppStart();
+    enableLegacyProfiling = options.isEnableLegacyProfiling();
   }
 
   public void setProfileSampled(final boolean profileSampled) {
@@ -160,6 +163,14 @@ public boolean isStartProfilerOnAppStart() {
     return isStartProfilerOnAppStart;
   }
 
+  public void setEnableLegacyProfiling(final boolean enableLegacyProfiling) {
+    this.enableLegacyProfiling = enableLegacyProfiling;
+  }
+
+  public boolean isEnableLegacyProfiling() {
+    return enableLegacyProfiling;
+  }
+
   // JsonSerializable
 
   public static final class JsonKeys {
@@ -175,6 +186,7 @@ public static final class JsonKeys {
     public static final String PROFILING_TRACES_HZ = "profiling_traces_hz";
     public static final String IS_ENABLE_APP_START_PROFILING = "is_enable_app_start_profiling";
     public static final String IS_START_PROFILER_ON_APP_START = "is_start_profiler_on_app_start";
+    public static final String ENABLE_LEGACY_PROFILING = "enable_legacy_profiling";
   }
 
   @Override
@@ -195,6 +207,7 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
     writer.name(JsonKeys.PROFILING_TRACES_HZ).value(logger, profilingTracesHz);
     writer.name(JsonKeys.IS_ENABLE_APP_START_PROFILING).value(logger, isEnableAppStartProfiling);
     writer.name(JsonKeys.IS_START_PROFILER_ON_APP_START).value(logger, isStartProfilerOnAppStart);
+    writer.name(JsonKeys.ENABLE_LEGACY_PROFILING).value(logger, enableLegacyProfiling);
 
     if (unknown != null) {
       for (String key : unknown.keySet()) {
@@ -308,6 +321,12 @@ public static final class Deserializer
               options.isStartProfilerOnAppStart = isStartProfilerOnAppStart;
             }
             break;
+          case JsonKeys.ENABLE_LEGACY_PROFILING:
+            @Nullable Boolean enableLegacyProfiling = reader.nextBooleanOrNull();
+            if (enableLegacyProfiling != null) {
+              options.enableLegacyProfiling = enableLegacyProfiling;
+            }
+            break;
           default:
             if (unknown == null) {
               unknown = new ConcurrentHashMap<>();
diff --git a/sentry/src/main/java/io/sentry/SentryClient.java b/sentry/src/main/java/io/sentry/SentryClient.java
index a25aa9c79e1..92037f6690b 100644
--- a/sentry/src/main/java/io/sentry/SentryClient.java
+++ b/sentry/src/main/java/io/sentry/SentryClient.java
@@ -1131,12 +1131,19 @@ public void captureSession(final @NotNull Session session, final @Nullable Hint
     // BeforeSend and EventProcessors are not supported at the moment for Profile Chunks
 
     try {
+      final SentryEnvelopeItem envelopeItem;
+      if (ProfileChunk.CONTENT_TYPE_PERFETTO.equals(profileChunk.getContentType())) {
+        envelopeItem =
+            SentryEnvelopeItem.fromPerfettoProfileChunk(profileChunk, options.getSerializer());
+      } else {
+        envelopeItem =
+            SentryEnvelopeItem.fromProfileChunk(
+                profileChunk, options.getSerializer(), options.getProfilerConverter());
+      }
       final @NotNull SentryEnvelope envelope =
           new SentryEnvelope(
               new SentryEnvelopeHeader(sentryId, options.getSdkVersion(), null),
-              Collections.singletonList(
-                  SentryEnvelopeItem.fromProfileChunk(
-                      profileChunk, options.getSerializer(), options.getProfilerConverter())));
+              Collections.singletonList(envelopeItem));
       sentryId = sendEnvelope(envelope, null);
     } catch (IOException | SentryEnvelopeException e) {
       options
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
index 728478f5906..2a7f06968dc 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItem.java
@@ -28,6 +28,7 @@
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicReference;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -385,6 +386,79 @@ private static void ensureAttachmentSizeLimit(
     return new SentryEnvelopeItem(itemHeader, () -> cachedItem.getBytes());
   }
 
+  public static @NotNull SentryEnvelopeItem fromPerfettoProfileChunk(
+      final @NotNull ProfileChunk profileChunk, final @NotNull ISerializer serializer)
+      throws SentryEnvelopeException {
+
+    final @Nullable File traceFile = profileChunk.getTraceFile();
+
+    if (traceFile == null || !traceFile.exists()) {
+      throw new SentryEnvelopeException(
+          String.format(
+              "Dropping perfetto profile chunk, because the trace file '%s' doesn't exist",
+              traceFile != null ? traceFile.getName() : "null"));
+    }
+
+    // Perfetto profile chunks are serialized as [JSON metadata][raw .pftrace bytes] with no
+    // delimiter. The server needs meta_length in the envelope header to know where the JSON
+    // ends and the binary begins. meta_length is not known until the CachedItem payload lambda
+    // runs, so we track it here as an envelope serialization concern rather than on ProfileChunk.
+    final AtomicReference<Integer> metaLength = new AtomicReference<>(null);
+
+    final CachedItem cachedItem =
+        new CachedItem(
+            () -> {
+              // Serialize JSON metadata
+              final byte[] metadataBytes;
+              try (final ByteArrayOutputStream stream = new ByteArrayOutputStream();
+                  final Writer writer = new BufferedWriter(new OutputStreamWriter(stream, UTF_8))) {
+                serializer.serialize(profileChunk, writer);
+                writer.flush();
+                metadataBytes = stream.toByteArray();
+                metaLength.set(metadataBytes.length);
+              } catch (IOException e) {
+                throw new SentryEnvelopeException(
+                    String.format(
+                        "Failed to serialize perfetto profile chunk\n%s", e.getMessage()));
+              }
+
+              // Read binary Perfetto trace
+              final byte[] traceBytes;
+              try {
+                traceBytes = readBytesFromFile(traceFile.getPath(), MAX_PROFILE_CHUNK_SIZE);
+              } catch (IOException e) {
+                throw new SentryEnvelopeException(
+                    String.format("Failed to read perfetto trace file\n%s", e.getMessage()));
+              } finally {
+                traceFile.delete();
+              }
+
+              // Concatenate: [JSON metadata bytes][raw .pftrace binary bytes]
+              final byte[] payload = new byte[metadataBytes.length + traceBytes.length];
+              System.arraycopy(metadataBytes, 0, payload, 0, metadataBytes.length);
+              System.arraycopy(traceBytes, 0, payload, metadataBytes.length, traceBytes.length);
+
+              return payload;
+            });
+
+    SentryEnvelopeItemHeader itemHeader =
+        new SentryEnvelopeItemHeader(
+            SentryItemType.ProfileChunk,
+            () -> cachedItem.getBytes().length,
+            profileChunk.getContentType(),
+            traceFile.getName(),
+            null,
+            profileChunk.getPlatform(),
+            null,
+            // avoid method refs on Android due to some issues with older AGP setups
+            // noinspection Convert2MethodRef
+            () -> metaLength.get());
+
+    // avoid method refs on Android due to some issues with older AGP setups
+    // noinspection Convert2MethodRef
+    return new SentryEnvelopeItem(itemHeader, () -> cachedItem.getBytes());
+  }
+
   public static @NotNull SentryEnvelopeItem fromProfilingTrace(
       final @NotNull ProfilingTraceData profilingTraceData,
       final long maxTraceFileSize,
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
index 25f1e893fc3..fea98a66767 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
@@ -21,6 +21,7 @@ public final class SentryEnvelopeItemHeader implements JsonSerializable, JsonUnk
   private final int length;
   @Nullable private final Callable<Integer> getLength;
   private final @Nullable String attachmentType;
+  @Nullable private final Callable<Integer> calculateMetaLength;
 
   private @Nullable Map<String, Object> unknown;
 
@@ -52,32 +53,97 @@ public int getLength() {
     return platform;
   }
 
-  @ApiStatus.Internal
-  public SentryEnvelopeItemHeader(
+  @Nullable
+  Integer getMetaLength() {
+    if (calculateMetaLength != null) {
+      try {
+        return calculateMetaLength.call();
+      } catch (Throwable ignored) {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  private SentryEnvelopeItemHeader(
       final @NotNull SentryItemType type,
       int length,
+      final @Nullable Callable<Integer> getLength,
       final @Nullable String contentType,
       final @Nullable String fileName,
       final @Nullable String attachmentType,
       final @Nullable String platform,
-      final @Nullable Integer itemCount) {
+      final @Nullable Integer itemCount,
+      final @Nullable Callable<Integer> calculateMetaLength) {
     this.type = Objects.requireNonNull(type, "type is required");
     this.contentType = contentType;
     this.length = length;
     this.fileName = fileName;
-    this.getLength = null;
+    this.getLength = getLength;
     this.attachmentType = attachmentType;
     this.platform = platform;
     this.itemCount = itemCount;
+    this.calculateMetaLength = calculateMetaLength;
+  }
+
+  /** Eager constructor used internally by {@link Deserializer#deserialize}. */
+  @ApiStatus.Internal
+  private SentryEnvelopeItemHeader(
+      final @NotNull SentryItemType type,
+      int length,
+      final @Nullable String contentType,
+      final @Nullable String fileName,
+      final @Nullable String attachmentType,
+      final @Nullable String platform,
+      final @Nullable Integer itemCount,
+      final @Nullable Integer metaLength) {
+    this(
+        type,
+        length,
+        null,
+        contentType,
+        fileName,
+        attachmentType,
+        platform,
+        itemCount,
+        metaLength != null ? () -> metaLength : null);
+  }
+
+  @ApiStatus.Internal
+  public SentryEnvelopeItemHeader(
+      final @NotNull SentryItemType type,
+      int length,
+      final @Nullable String contentType,
+      final @Nullable String fileName,
+      final @Nullable String attachmentType,
+      final @Nullable String platform,
+      final @Nullable Integer itemCount) {
+    this(type, length, contentType, fileName, attachmentType, platform, itemCount, null);
   }
 
+  /**
+   * Lazy constructor. Both length and metaLength are computed lazily as these depend on the Item
+   * having been evaluated.
+   */
   SentryEnvelopeItemHeader(
       final @NotNull SentryItemType type,
       final @Nullable Callable<Integer> getLength,
       final @Nullable String contentType,
       final @Nullable String fileName,
-      final @Nullable String attachmentType) {
-    this(type, getLength, contentType, fileName, attachmentType, null, null);
+      final @Nullable String attachmentType,
+      final @Nullable String platform,
+      final @Nullable Integer itemCount,
+      final @Nullable Callable<Integer> calculateMetaLength) {
+    this(
+        type,
+        -1,
+        getLength,
+        contentType,
+        fileName,
+        attachmentType,
+        platform,
+        itemCount,
+        calculateMetaLength);
   }
 
   SentryEnvelopeItemHeader(
@@ -88,14 +154,16 @@ public SentryEnvelopeItemHeader(
       final @Nullable String attachmentType,
       final @Nullable String platform,
       final @Nullable Integer itemCount) {
-    this.type = Objects.requireNonNull(type, "type is required");
-    this.contentType = contentType;
-    this.length = -1;
-    this.fileName = fileName;
-    this.getLength = getLength;
-    this.attachmentType = attachmentType;
-    this.platform = platform;
-    this.itemCount = itemCount;
+    this(type, getLength, contentType, fileName, attachmentType, platform, itemCount, null);
+  }
+
+  SentryEnvelopeItemHeader(
+      final @NotNull SentryItemType type,
+      final @Nullable Callable<Integer> getLength,
+      final @Nullable String contentType,
+      final @Nullable String fileName,
+      final @Nullable String attachmentType) {
+    this(type, getLength, contentType, fileName, attachmentType, null, null);
   }
 
   SentryEnvelopeItemHeader(
@@ -125,6 +193,7 @@ public static final class JsonKeys {
     public static final String LENGTH = "length";
     public static final String PLATFORM = "platform";
     public static final String ITEM_COUNT = "item_count";
+    public static final String META_LENGTH = "meta_length";
   }
 
   @Override
@@ -148,6 +217,10 @@ public void serialize(final @NotNull ObjectWriter writer, final @NotNull ILogger
       writer.name(JsonKeys.ITEM_COUNT).value(itemCount);
     }
     writer.name(JsonKeys.LENGTH).value(getLength());
+    final @Nullable Integer resolvedMetaLength = getMetaLength();
+    if (resolvedMetaLength != null) {
+      writer.name(JsonKeys.META_LENGTH).value(resolvedMetaLength);
+    }
     if (unknown != null) {
       for (String key : unknown.keySet()) {
         Object value = unknown.get(key);
@@ -171,6 +244,7 @@ public static final class Deserializer implements JsonDeserializer<SentryEnvelop
       String attachmentType = null;
       String platform = null;
       Integer itemCount = null;
+      Integer metaLength = null;
       Map<String, Object> unknown = null;
 
       while (reader.peek() == JsonToken.NAME) {
@@ -197,6 +271,9 @@ public static final class Deserializer implements JsonDeserializer<SentryEnvelop
           case JsonKeys.ITEM_COUNT:
             itemCount = reader.nextIntegerOrNull();
             break;
+          case JsonKeys.META_LENGTH:
+            metaLength = reader.nextIntegerOrNull();
+            break;
           default:
             if (unknown == null) {
               unknown = new HashMap<>();
@@ -210,7 +287,7 @@ public static final class Deserializer implements JsonDeserializer<SentryEnvelop
       }
       SentryEnvelopeItemHeader sentryEnvelopeItemHeader =
           new SentryEnvelopeItemHeader(
-              type, length, contentType, fileName, attachmentType, platform, itemCount);
+              type, length, contentType, fileName, attachmentType, platform, itemCount, metaLength);
       sentryEnvelopeItemHeader.setUnknown(unknown);
       reader.endObject();
       return sentryEnvelopeItemHeader;
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index 93104101f81..dc9d9521dbb 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -657,6 +657,14 @@ public class SentryOptions {
    */
   private boolean startProfilerOnAppStart = false;
 
+  /**
+   * When false, the legacy {@code Debug}-based profiler is disabled on API &lt; 35 devices. On API
+   * 35+ devices, Android's {@code ProfilingManager} (Perfetto-based stack sampling) is always used
+   * regardless of this setting. This option will be deprecated in the next major release and
+   * removed in the one after.
+   */
+  private boolean enableLegacyProfiling = true;
+
   /**
    * Controls the deadline timeout in milliseconds for automatic transactions. When set to a
    * positive value, that value is used as the deadline timeout. When set to a value less than or
@@ -2284,6 +2292,36 @@ public void setStartProfilerOnAppStart(final boolean startProfilerOnAppStart) {
     this.startProfilerOnAppStart = startProfilerOnAppStart;
   }
 
+  /**
+   * Whether the legacy {@code Debug}-based profiler is enabled. This controls continuous profiling
+   * on API &lt; 35 devices (on API 35+, Android's {@code ProfilingManager} / Perfetto is always
+   * used for continuous profiling regardless of this setting) as well as transaction-based
+   * profiling ({@code profilesSampleRate}/{@code profilesSampler}) on all devices, since
+   * transaction-based profiling always relies on the legacy profiler and is not supported by
+   * Perfetto. This option will be deprecated in the next major release and removed in the one
+   * after.
+   *
+   * @return true if legacy profiling is enabled (default).
+   */
+  public boolean isEnableLegacyProfiling() {
+    return enableLegacyProfiling;
+  }
+
+  /**
+   * Set whether the legacy {@code Debug}-based profiler is enabled. Set to {@code false} to disable
+   * continuous profiling on devices below API 35 (on API 35+ devices, Android's {@code
+   * ProfilingManager} / Perfetto is always used for continuous profiling and this setting has no
+   * effect) as well as transaction-based profiling ({@code profilesSampleRate}/{@code
+   * profilesSampler}) on all devices, since transaction-based profiling always relies on the legacy
+   * profiler and is not supported by Perfetto. This option will be deprecated in the next major
+   * release and removed in the one after.
+   *
+   * @param enableLegacyProfiling false to disable legacy profiling.
+   */
+  public void setEnableLegacyProfiling(final boolean enableLegacyProfiling) {
+    this.enableLegacyProfiling = enableLegacyProfiling;
+  }
+
   public long getDeadlineTimeout() {
     return deadlineTimeout;
   }
diff --git a/sentry/src/test/java/io/sentry/JsonSerializerTest.kt b/sentry/src/test/java/io/sentry/JsonSerializerTest.kt
index f9308a9123a..95b664e13a9 100644
--- a/sentry/src/test/java/io/sentry/JsonSerializerTest.kt
+++ b/sentry/src/test/java/io/sentry/JsonSerializerTest.kt
@@ -1345,7 +1345,8 @@ class JsonSerializerTest {
       "{\"profile_sampled\":true,\"profile_sample_rate\":0.8,\"continuous_profile_sampled\":true," +
         "\"trace_sampled\":false,\"trace_sample_rate\":0.1,\"profiling_traces_dir_path\":null,\"is_profiling_enabled\":false," +
         "\"is_continuous_profiling_enabled\":false,\"profile_lifecycle\":\"TRACE\",\"profiling_traces_hz\":65," +
-        "\"is_enable_app_start_profiling\":false,\"is_start_profiler_on_app_start\":true}"
+        "\"is_enable_app_start_profiling\":false,\"is_start_profiler_on_app_start\":true," +
+        "\"enable_legacy_profiling\":true}"
     assertEquals(expected, actual)
   }
 
diff --git a/sentry/src/test/java/io/sentry/SentryEnvelopeItemTest.kt b/sentry/src/test/java/io/sentry/SentryEnvelopeItemTest.kt
index 858ca43ab11..9f006ed94e9 100644
--- a/sentry/src/test/java/io/sentry/SentryEnvelopeItemTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryEnvelopeItemTest.kt
@@ -2,6 +2,7 @@ package io.sentry
 
 import io.sentry.exception.SentryEnvelopeException
 import io.sentry.protocol.ReplayRecordingSerializationTest
+import io.sentry.protocol.SentryId
 import io.sentry.protocol.SentryReplayEventSerializationTest
 import io.sentry.protocol.User
 import io.sentry.protocol.ViewHierarchy
@@ -13,6 +14,7 @@ import java.io.File
 import java.io.IOException
 import java.io.InputStreamReader
 import java.io.OutputStreamWriter
+import java.io.StringWriter
 import java.nio.charset.Charset
 import java.nio.file.Files
 import java.util.concurrent.Callable
@@ -23,6 +25,7 @@ import kotlin.test.assertFailsWith
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
+import kotlin.test.assertTrue
 import org.junit.Assert.assertArrayEquals
 import org.junit.Rule
 import org.junit.rules.TemporaryFolder
@@ -596,6 +599,102 @@ class SentryEnvelopeItemTest {
     )
   }
 
+  @Test
+  fun `fromPerfettoProfileChunk produces concatenated JSON+binary payload`() {
+    val traceFile = tmpDir.newFile("trace.pftrace")
+    val traceBytes = byteArrayOf(0x50, 0x65, 0x72, 0x66) // "Perf"
+    traceFile.writeBytes(traceBytes)
+
+    val profileChunk =
+      ProfileChunk.Builder(
+          SentryId(),
+          SentryId(),
+          emptyMap(),
+          traceFile,
+          SentryNanotimeDate(),
+          ProfileChunk.PLATFORM_ANDROID,
+        )
+        .setContentType(ProfileChunk.CONTENT_TYPE_PERFETTO)
+        .build(fixture.options)
+
+    val item = SentryEnvelopeItem.fromPerfettoProfileChunk(profileChunk, fixture.serializer)
+
+    assertEquals(SentryItemType.ProfileChunk, item.header.type)
+    assertEquals(ProfileChunk.CONTENT_TYPE_PERFETTO, item.header.contentType)
+    assertEquals("android", item.header.platform)
+
+    val payload = item.data
+    assertNotNull(item.header.metaLength)
+    val metaLength = item.header.metaLength!!
+    // Payload should be: [JSON metadata][binary trace]
+    val metadataBytes = payload.copyOfRange(0, metaLength)
+    val binaryBytes = payload.copyOfRange(metaLength, payload.size)
+
+    // Metadata should be valid JSON containing content_type
+    val metadataJson = String(metadataBytes, Charsets.UTF_8)
+    assert(metadataJson.contains("\"content_type\":\"application/x-perfetto-trace\""))
+    assert(metadataJson.contains("\"version\":\"2\""))
+
+    // Binary bytes should match original trace file
+    assertArrayEquals(traceBytes, binaryBytes)
+
+    // Trace file should be deleted
+    assertFalse(traceFile.exists())
+  }
+
+  @Test
+  fun `fromPerfettoProfileChunk header serializes with meta_length`() {
+    val traceFile = tmpDir.newFile("trace.pftrace")
+    traceFile.writeBytes(byteArrayOf(0x50, 0x65, 0x72, 0x66))
+
+    val profileChunk =
+      ProfileChunk.Builder(
+          SentryId(),
+          SentryId(),
+          emptyMap(),
+          traceFile,
+          SentryNanotimeDate(),
+          ProfileChunk.PLATFORM_ANDROID,
+        )
+        .setContentType(ProfileChunk.CONTENT_TYPE_PERFETTO)
+        .build(fixture.options)
+
+    val item = SentryEnvelopeItem.fromPerfettoProfileChunk(profileChunk, fixture.serializer)
+
+    // Serialize the header without pre-materializing item.data.
+    val sw = StringWriter()
+    val writer = JsonObjectWriter(sw, 100)
+    item.header.serialize(writer, mock<ILogger>())
+
+    val json = sw.toString()
+    val metaLength = item.header.metaLength!!
+    assertTrue(metaLength > 0, "expected positive meta_length, was $metaLength")
+    assertTrue(
+      json.contains("\"meta_length\":$metaLength"),
+      "expected meta_length=$metaLength in header JSON, was: $json",
+    )
+  }
+
+  @Test
+  fun `fromPerfettoProfileChunk with missing file throws`() {
+    val traceFile = File("nonexistent.pftrace")
+    val profileChunk =
+      ProfileChunk.Builder(
+          SentryId(),
+          SentryId(),
+          emptyMap(),
+          traceFile,
+          SentryNanotimeDate(),
+          ProfileChunk.PLATFORM_ANDROID,
+        )
+        .setContentType(ProfileChunk.CONTENT_TYPE_PERFETTO)
+        .build(fixture.options)
+
+    assertFailsWith<SentryEnvelopeException> {
+      SentryEnvelopeItem.fromPerfettoProfileChunk(profileChunk, fixture.serializer)
+    }
+  }
+
   @Test
   fun `fromReplay encodes payload into msgpack`() {
     val file = Files.createTempFile("replay", "").toFile()
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index 9402c6fee9b..f1ee97459a1 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -782,6 +782,17 @@ class SentryOptionsTest {
     assertTrue(options.isEnableAppStartProfiling)
   }
 
+  @Test
+  fun `when options are initialized, enableLegacyProfiling is set to true by default`() {
+    assertTrue(SentryOptions().isEnableLegacyProfiling)
+  }
+
+  @Test
+  fun `when setEnableLegacyProfiling is called, value is set`() {
+    val options = SentryOptions().apply { isEnableLegacyProfiling = false }
+    assertFalse(options.isEnableLegacyProfiling)
+  }
+
   @Test
   fun `when options are initialized, profilingTracesHz is set to 101 by default`() {
     assertEquals(101, SentryOptions().profilingTracesHz)

From 1c74da096d5d539766ea2005f711ad4c0b766954 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Wed, 29 Jul 2026 19:29:52 +0200
Subject: [PATCH 343/391] chore(changelog): Fix Changelog (#5868)

---
 CHANGELOG.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d05335e9aa3..40b90b6f30a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -28,6 +28,9 @@
 - Prevent concurrent PixelCopy access during Session Replay masking and bitmap cleanup ([#5808](https://github.com/getsentry/sentry-java/pull/5808))
 - Release `MediaMuxer` when the replay video encoder fails to start to avoid a resource leak ([#5607](https://github.com/getsentry/sentry-java/pull/5607))
 - Set the correct platform (`android` instead of `java`) on ANR profile chunks so they are billed as UI Profile Hours rather than Continuous Profile Hours ([#5836](https://github.com/getsentry/sentry-java/pull/5836))
+- Skip encoding and capturing buffered session replay segments while rate-limited, so we don't waste resources on envelopes the transport will drop ([#5813](https://github.com/getsentry/sentry-java/pull/5813))
+  - These skipped replays are now reported as `ratelimit_backoff` discarded events in client reports, so they no longer disappear from drop statistics. One event is recorded per buffer flush rather than per segment.
+  - Buffer mode is also kept while rate-limited instead of switching to session mode, so the rolling buffer stays warm and the next error after the rate limit expires can send a complete replay.
 
 ### Performance
 
@@ -56,9 +59,6 @@
 
 ### Fixes
 
-- Skip encoding and capturing buffered session replay segments while rate-limited, so we don't waste resources on envelopes the transport will drop ([#5813](https://github.com/getsentry/sentry-java/pull/5813))
-  - These skipped replays are now reported as `ratelimit_backoff` discarded events in client reports, so they no longer disappear from drop statistics. One event is recorded per buffer flush rather than per segment.
-  - Buffer mode is also kept while rate-limited instead of switching to session mode, so the rolling buffer stays warm and the next error after the rate limit expires can send a complete replay.
 - Reduce main-thread work during `Sentry.init` by resolving the shake-detector accelerometer off the main thread (~1.75ms on a Pixel 10) ([#5784](https://github.com/getsentry/sentry-java/pull/5784))
 - Backfill release, environment, distribution, tags, and app version/build—and use the matching replay-on-error sample rate—for `ApplicationExitInfo` ANR and native crash events captured before SDK initialization, without reusing options cached by a later app update ([#5762](https://github.com/getsentry/sentry-java/pull/5762))
 - `SentryTagModifierNode.isImportantForBounds` now matches the default behavior and returns `true` ([#5789](https://github.com/getsentry/sentry-java/pull/5789))

From b01b159cce519c2da9db6303c8e9b64cdefd7b51 Mon Sep 17 00:00:00 2001
From: markushi <1411808+markushi@users.noreply.github.com>
Date: Wed, 29 Jul 2026 17:32:24 +0000
Subject: [PATCH 344/391] release: 8.51.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 40b90b6f30a..24d0d0740cf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.51.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index 669629ea17f..5558c29164f 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -16,7 +16,7 @@ android.newDsl=false
 android.experimental.lint.version=9.2.1
 
 # Release information
-versionName=8.50.0
+versionName=8.51.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 82973ef23e41feaa5e8fad5987ddee7ad17ebfdb Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 30 Jul 2026 10:26:04 +0200
Subject: [PATCH 345/391] chore(deps): bump the github-actions group with 2
 updates (#5869)

Bumps the github-actions group with 2 updates: [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) and [getsentry/craft](https://github.com/getsentry/craft).


Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.27.0 to 2.27.2
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/667b5f5669552a35990a11ff6ac1131febb07446...8fd703e550582184dafbf70d704ce33786e459e6)

Updates `getsentry/craft` from 2.27.0 to 2.27.2
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/667b5f5669552a35990a11ff6ac1131febb07446...8fd703e550582184dafbf70d704ce33786e459e6)

---
updated-dependencies:
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.27.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: getsentry/craft
  dependency-version: 2.27.2
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/changelog-preview.yml | 2 +-
 .github/workflows/release.yml           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index 0bfa9bb2d03..c2ab5983c3a 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@667b5f5669552a35990a11ff6ac1131febb07446 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@8fd703e550582184dafbf70d704ce33786e459e6 # v2
     secrets: inherit
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 704734bcbaa..8c79ef8e541 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@667b5f5669552a35990a11ff6ac1131febb07446 # v2
+        uses: getsentry/craft@8fd703e550582184dafbf70d704ce33786e459e6 # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:

From 337a9f1f5a6d26af28d3ba71609b5d027d10fb4c Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 30 Jul 2026 10:52:36 +0200
Subject: [PATCH 346/391] ref(android): Remove unused lock from
 SentryPerformanceProvider (#5871)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* ref(android): Remove unused lock from SentryPerformanceProvider

The field was added in #3715 to guard onAppStartDone(), its only user. That
method was removed in the 8.x.x merge (#4033), leaving the lock orphaned — it
has been allocated on every cold start since, in ContentProvider.onCreate,
without ever being acquired.

The ISentryLifecycleToken import stays: it is still used for
AppStartMetrics.staticLock in shutdown().

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                                | 6 ++++++
 .../io/sentry/android/core/SentryPerformanceProvider.java   | 2 --
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 24d0d0740cf..1823146d55a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Performance
+
+- Remove an unused lock from `SentryPerformanceProvider`, which was allocated on every cold start in `ContentProvider.onCreate` without ever being acquired ([#5871](https://github.com/getsentry/sentry-java/pull/5871))
+
 ## 8.51.0
 
 ### Features
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
index c85fe12674d..c37d384aeec 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
@@ -23,7 +23,6 @@
 import io.sentry.android.core.internal.util.SentryFrameMetricsCollector;
 import io.sentry.android.core.performance.AppStartMetrics;
 import io.sentry.android.core.performance.TimeSpan;
-import io.sentry.util.AutoClosableReentrantLock;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
@@ -46,7 +45,6 @@ public final class SentryPerformanceProvider extends EmptySecureContentProvider
 
   private final @NotNull ILogger logger;
   private final @NotNull BuildInfoProvider buildInfoProvider;
-  private final @NotNull AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
 
   @TestOnly
   SentryPerformanceProvider(

From 69bdef7a1e1a883b5aa44ddaa2999fa494677bd4 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 30 Jul 2026 11:57:18 +0200
Subject: [PATCH 347/391] perf(android): Parse app start profiling config
 without JsonSerializer (#5867)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* perf(android): Parse app start profiling config without JsonSerializer (JAVA-621)

SentryPerformanceProvider.launchAppStartProfiler ran in ContentProvider.onCreate
— main thread, before Application.onCreate, on every cold start — and built a
full JsonSerializer(SentryOptions.empty()) to read one small config file.

That path only ever reads options.getLogger(), but JsonSerializer's constructor
registers every known deserializer to use exactly one of them. Calling the
deserializer directly cuts the parse from 221 to 33 allocations and ~7.5us to
~3.7us (Pixel 10, androidx Microbenchmark, allocationCount is deterministic).

Malformed input still yields null so callers keep reporting it as a
deserialization failure rather than a read error.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* changelog

* ref(android): Catch only expected exceptions when parsing profiling config

Narrow the deserialization catch from Throwable to Exception. The vendored JSON
reader signals bad input with IOException (MalformedJsonException, EOFException),
IllegalStateException on token type mismatch, and NumberFormatException on an
unparseable number — all Exception subclasses. Catching Throwable additionally
swallowed Error, which is never a recoverable "config file is bad" signal.

This also restores parity with JsonSerializer.deserialize, which catches
Exception, so the replaced behaviour is matched exactly rather than widened.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* ref(android): Trim javadoc on deserializeProfilingConfig

Drop the paragraph enumerating which exception types the vendored JSON reader
throws. That catch (Exception) does not swallow Error is a language-level
given, and listing the reader's internal exception types invites the comment
to drift as that code changes. The rationale a reader cannot infer from the
code — why the deserializer is called directly, and why null is returned
instead of rethrowing — stays.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../core/SentryPerformanceProvider.java       | 24 ++++++++++++++++---
 .../core/SentryPerformanceProviderTest.kt     | 15 ++++++++++++
 3 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1823146d55a..b52621fae5a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 ### Performance
 
 - Remove an unused lock from `SentryPerformanceProvider`, which was allocated on every cold start in `ContentProvider.onCreate` without ever being acquired ([#5871](https://github.com/getsentry/sentry-java/pull/5871))
+- Parse the app start profiling config with only the deserializer it needs instead of building a full `JsonSerializer` and `SentryOptions`, cutting 188 of 221 allocations on the main thread before `Application.onCreate` ([#5867](https://github.com/getsentry/sentry-java/pull/5867))
 
 ## 8.51.0
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
index c37d384aeec..9d1f2e13ec4 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryPerformanceProvider.java
@@ -13,7 +13,7 @@
 import io.sentry.ILogger;
 import io.sentry.ISentryLifecycleToken;
 import io.sentry.ITransactionProfiler;
-import io.sentry.JsonSerializer;
+import io.sentry.JsonObjectReader;
 import io.sentry.SentryAppStartProfilingOptions;
 import io.sentry.SentryExecutorService;
 import io.sentry.SentryLevel;
@@ -117,8 +117,7 @@ private void launchAppStartProfiler(final @NotNull AppStartMetrics appStartMetri
     try (final @NotNull Reader reader =
             new BufferedReader(new InputStreamReader(new FileInputStream(configFile)))) {
       final @Nullable SentryAppStartProfilingOptions profilingOptions =
-          new JsonSerializer(SentryOptions.empty())
-              .deserialize(reader, SentryAppStartProfilingOptions.class);
+          deserializeProfilingConfig(reader);
 
       if (profilingOptions == null) {
         logger.log(
@@ -166,6 +165,25 @@ private void launchAppStartProfiler(final @NotNull AppStartMetrics appStartMetri
     }
   }
 
+  /**
+   * Parses the app start profiling config with only the deserializer it needs. Going through {@link
+   * io.sentry.JsonSerializer} would allocate a full {@link SentryOptions} plus every registered
+   * deserializer on the main thread before {@code Application.onCreate}, to use exactly one of
+   * them.
+   *
+   * <p>Returns null on malformed input, matching what {@code JsonSerializer.deserialize} did, so
+   * callers keep reporting it as a deserialization failure rather than a read error.
+   */
+  private @Nullable SentryAppStartProfilingOptions deserializeProfilingConfig(
+      final @NotNull Reader reader) {
+    try (final @NotNull JsonObjectReader jsonReader = new JsonObjectReader(reader)) {
+      return new SentryAppStartProfilingOptions.Deserializer().deserialize(jsonReader, logger);
+    } catch (Exception e) {
+      logger.log(SentryLevel.ERROR, "Error when deserializing", e);
+      return null;
+    }
+  }
+
   private void createAndStartContinuousProfiler(
       final @NotNull Context context,
       final @NotNull SentryAppStartProfilingOptions profilingOptions,
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt
index 254571181a6..bff6cdfad37 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryPerformanceProviderTest.kt
@@ -153,6 +153,21 @@ class SentryPerformanceProviderTest {
       )
   }
 
+  @Test
+  fun `when config file is malformed, profiler is not started`() {
+    fixture.getSut { config -> config.writeText("{\"profile_sampled\": tru") }
+    assertNull(AppStartMetrics.getInstance().appStartProfiler)
+    assertNull(AppStartMetrics.getInstance().appStartContinuousProfiler)
+    verify(fixture.logger).log(eq(SentryLevel.ERROR), eq("Error when deserializing"), any())
+    verify(fixture.logger)
+      .log(
+        eq(SentryLevel.WARNING),
+        eq(
+          "Unable to deserialize the SentryAppStartProfilingOptions. App start profiling will not start."
+        ),
+      )
+  }
+
   @Test
   fun `when profiling is disabled, profiler is not started`() {
     fixture.getSut { config ->

From 0ab689f6fbec7e82b21c1083337e6e64c7c0a9d2 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 30 Jul 2026 13:04:09 +0200
Subject: [PATCH 348/391] fix(clientreport): Stop deserializing discarded logs
 (JAVA-662) (#5835)

* fix(clientreport): Stop deserializing discarded logs (JAVA-662)

ClientReportRecorder counted discarded log and metric items by fully
deserializing the envelope payload just to read its size. On the discard
path this runs continuously under sustained rate limiting, and the JSON
reader's error-tolerant recovery throws an exception per token, pinning
CPU cores in a busy-loop (fillInStackTrace dominated the profile).

The item count is already stored in the envelope item header, so read it
from there instead of deserializing. Byte counts still come from the raw
data. This makes the discard path O(1) and allocation/exception-free.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

* test(clientreport): Cover both onDiscard restore entry points (JAVA-662)

The two tests asserting that restoring counts from an attached client
report does not re-fire onDiscard were named for their setup rather than
for what actually differed between them, which made the pair read as an
accidental duplicate.

Name each for its entry point and share the setup and verifications, so
it is clear the property is being pinned for both recordLostEnvelope and
recordLostEnvelopeItem.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   5 +
 sentry/api/sentry.api                         |   1 +
 .../io/sentry/SentryEnvelopeItemHeader.java   |   4 +
 .../clientreport/ClientReportRecorder.java    |  50 +++----
 .../sentry/clientreport/ClientReportTest.kt   | 139 +++++++++++++++---
 5 files changed, 145 insertions(+), 54 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b52621fae5a..89d412bcfdd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+### Fixes
+
+- Avoid a CPU busy-loop when recording discarded log or metric envelopes under rate limiting ([#5835](https://github.com/getsentry/sentry-java/pull/5835))
+  - `ClientReportRecorder` now reads the item count from the envelope item header instead of deserializing the payload, which under sustained rate limiting could pin CPU cores while repeatedly throwing exceptions
+
 ### Performance
 
 - Remove an unused lock from `SentryPerformanceProvider`, which was allocated on every cold start in `ContentProvider.onCreate` without ever being acquired ([#5871](https://github.com/getsentry/sentry-java/pull/5871))
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 7e258b0d4b1..e23f283d942 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -3120,6 +3120,7 @@ public final class io/sentry/SentryEnvelopeItemHeader : io/sentry/JsonSerializab
 	public fun getAttachmentType ()Ljava/lang/String;
 	public fun getContentType ()Ljava/lang/String;
 	public fun getFileName ()Ljava/lang/String;
+	public fun getItemCount ()Ljava/lang/Integer;
 	public fun getLength ()I
 	public fun getPlatform ()Ljava/lang/String;
 	public fun getType ()Lio/sentry/SentryItemType;
diff --git a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
index fea98a66767..eaacee9957a 100644
--- a/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
+++ b/sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java
@@ -53,6 +53,10 @@ public int getLength() {
     return platform;
   }
 
+  public @Nullable Integer getItemCount() {
+    return itemCount;
+  }
+
   @Nullable
   Integer getMetaLength() {
     if (calculateMetaLength != null) {
diff --git a/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java b/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
index b3756ed32e4..ccd7c5dc402 100644
--- a/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
+++ b/sentry/src/main/java/io/sentry/clientreport/ClientReportRecorder.java
@@ -6,10 +6,6 @@
 import io.sentry.SentryEnvelopeItem;
 import io.sentry.SentryItemType;
 import io.sentry.SentryLevel;
-import io.sentry.SentryLogEvent;
-import io.sentry.SentryLogEvents;
-import io.sentry.SentryMetricsEvent;
-import io.sentry.SentryMetricsEvents;
 import io.sentry.SentryOptions;
 import io.sentry.protocol.SentrySpan;
 import io.sentry.protocol.SentryTransaction;
@@ -105,34 +101,18 @@ public void recordLostEnvelopeItem(
           recordLostEventInternal(reason.getReason(), itemCategory.getCategory(), 1L);
           executeOnDiscard(reason, itemCategory, 1L);
         } else if (itemCategory.equals(DataCategory.LogItem)) {
-          final @Nullable SentryLogEvents logs = envelopeItem.getLogs(options.getSerializer());
-          if (logs != null) {
-            final @NotNull List<SentryLogEvent> items = logs.getItems();
-            final long count = items.size();
-            recordLostEventInternal(reason.getReason(), itemCategory.getCategory(), count);
-            final long logBytes = envelopeItem.getData().length;
-            recordLostEventInternal(
-                reason.getReason(), DataCategory.LogByte.getCategory(), logBytes);
-            executeOnDiscard(reason, itemCategory, count);
-          } else {
-            options.getLogger().log(SentryLevel.ERROR, "Unable to parse lost logs envelope item.");
-          }
+          final long count = itemCountFromHeader(envelopeItem);
+          recordLostEventInternal(reason.getReason(), itemCategory.getCategory(), count);
+          final long logBytes = envelopeItem.getData().length;
+          recordLostEventInternal(reason.getReason(), DataCategory.LogByte.getCategory(), logBytes);
+          executeOnDiscard(reason, itemCategory, count);
         } else if (itemCategory.equals(DataCategory.TraceMetric)) {
-          final @Nullable SentryMetricsEvents metrics =
-              envelopeItem.getMetrics(options.getSerializer());
-          if (metrics != null) {
-            final @NotNull List<SentryMetricsEvent> items = metrics.getItems();
-            final long count = items.size();
-            recordLostEventInternal(reason.getReason(), itemCategory.getCategory(), count);
-            final long metricBytes = envelopeItem.getData().length;
-            recordLostEventInternal(
-                reason.getReason(), DataCategory.TraceMetricByte.getCategory(), metricBytes);
-            executeOnDiscard(reason, itemCategory, count);
-          } else {
-            options
-                .getLogger()
-                .log(SentryLevel.ERROR, "Unable to parse lost metrics envelope item.");
-          }
+          final long count = itemCountFromHeader(envelopeItem);
+          recordLostEventInternal(reason.getReason(), itemCategory.getCategory(), count);
+          final long metricBytes = envelopeItem.getData().length;
+          recordLostEventInternal(
+              reason.getReason(), DataCategory.TraceMetricByte.getCategory(), metricBytes);
+          executeOnDiscard(reason, itemCategory, count);
         } else {
           recordLostEventInternal(reason.getReason(), itemCategory.getCategory(), 1L);
           executeOnDiscard(reason, itemCategory, 1L);
@@ -176,6 +156,14 @@ private void recordLostEventInternal(
     storage.addCount(key, countToAdd);
   }
 
+  // The number of items batched into a log or metric envelope item is stored in its header, so we
+  // read it from there instead of deserializing the payload. Deserializing on the discard path is
+  // expensive and, under sustained rate limiting, caused a CPU busy-loop (JAVA-662).
+  private long itemCountFromHeader(final @NotNull SentryEnvelopeItem envelopeItem) {
+    final @Nullable Integer itemCount = envelopeItem.getHeader().getItemCount();
+    return itemCount != null ? itemCount : 1L;
+  }
+
   @Nullable
   ClientReport resetCountsAndGenerateClientReport() {
     final Date currentDate = DateUtils.getCurrentDateTime();
diff --git a/sentry/src/test/java/io/sentry/clientreport/ClientReportTest.kt b/sentry/src/test/java/io/sentry/clientreport/ClientReportTest.kt
index ceb254213cb..b89b1894f32 100644
--- a/sentry/src/test/java/io/sentry/clientreport/ClientReportTest.kt
+++ b/sentry/src/test/java/io/sentry/clientreport/ClientReportTest.kt
@@ -15,7 +15,9 @@ import io.sentry.Sentry
 import io.sentry.SentryEnvelope
 import io.sentry.SentryEnvelopeHeader
 import io.sentry.SentryEnvelopeItem
+import io.sentry.SentryEnvelopeItemHeader
 import io.sentry.SentryEvent
+import io.sentry.SentryItemType
 import io.sentry.SentryLogEvent
 import io.sentry.SentryLogEvents
 import io.sentry.SentryLogLevel
@@ -46,11 +48,17 @@ import java.util.UUID
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
+import org.mockito.kotlin.any
+import org.mockito.kotlin.doReturn
 import org.mockito.kotlin.mock
+import org.mockito.kotlin.never
 import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 
+private const val LOG_CONTENT_TYPE = "application/vnd.sentry.items.log+json"
+private const val METRIC_CONTENT_TYPE = "application/vnd.sentry.items.trace-metric+json"
+
 class ClientReportTest {
   lateinit var opts: SentryOptions
   lateinit var clientReportRecorder: ClientReportRecorder
@@ -312,28 +320,24 @@ class ClientReportTest {
   }
 
   @Test
-  fun `recording envelope with lost client report does not duplicate onDiscard executions`() {
-    val onDiscardMock = mock<SentryOptions.OnDiscardCallback>()
-    givenClientReportRecorder { options -> options.onDiscard = onDiscardMock }
-
-    clientReportRecorder.recordLostEvent(DiscardReason.CACHE_OVERFLOW, DataCategory.Attachment)
-    clientReportRecorder.recordLostEvent(DiscardReason.CACHE_OVERFLOW, DataCategory.Attachment)
-    clientReportRecorder.recordLostEvent(DiscardReason.RATELIMIT_BACKOFF, DataCategory.Error)
-    clientReportRecorder.recordLostEvent(DiscardReason.QUEUE_OVERFLOW, DataCategory.Error)
-    clientReportRecorder.recordLostEvent(DiscardReason.BEFORE_SEND, DataCategory.Profile)
-
-    val envelope = clientReportRecorder.attachReportToEnvelope(testHelper.newEnvelope())
-    clientReportRecorder.recordLostEnvelope(DiscardReason.EVENT_PROCESSOR, envelope)
-
-    verify(onDiscardMock, times(2))
-      .execute(DiscardReason.CACHE_OVERFLOW, DataCategory.Attachment, 1)
-    verify(onDiscardMock, times(1)).execute(DiscardReason.RATELIMIT_BACKOFF, DataCategory.Error, 1)
-    verify(onDiscardMock, times(1)).execute(DiscardReason.QUEUE_OVERFLOW, DataCategory.Error, 1)
-    verify(onDiscardMock, times(1)).execute(DiscardReason.BEFORE_SEND, DataCategory.Profile, 1)
+  fun `restoring counts via recordLostEnvelope does not fire onDiscard again`() {
+    assertRestoringCountsDoesNotFireOnDiscard { recorder, envelope ->
+      recorder.recordLostEnvelope(DiscardReason.EVENT_PROCESSOR, envelope)
+    }
   }
 
   @Test
-  fun `recording lost client report does not duplicate onDiscard executions`() {
+  fun `restoring counts via recordLostEnvelopeItem does not fire onDiscard again`() {
+    assertRestoringCountsDoesNotFireOnDiscard { recorder, envelope ->
+      recorder.recordLostEnvelopeItem(DiscardReason.NETWORK_ERROR, envelope.items.first())
+    }
+  }
+
+  // Counts restored from an attached client report were already reported once, so replaying them
+  // must not fire onDiscard a second time. Both public entry points have to hold the property.
+  private fun assertRestoringCountsDoesNotFireOnDiscard(
+    recordLost: (ClientReportRecorder, SentryEnvelope) -> Unit
+  ) {
     val onDiscardMock = mock<SentryOptions.OnDiscardCallback>()
     givenClientReportRecorder { options -> options.onDiscard = onDiscardMock }
 
@@ -344,7 +348,7 @@ class ClientReportTest {
     clientReportRecorder.recordLostEvent(DiscardReason.BEFORE_SEND, DataCategory.Profile)
 
     val envelope = clientReportRecorder.attachReportToEnvelope(testHelper.newEnvelope())
-    clientReportRecorder.recordLostEnvelopeItem(DiscardReason.NETWORK_ERROR, envelope.items.first())
+    recordLost(clientReportRecorder, envelope)
 
     verify(onDiscardMock, times(2))
       .execute(DiscardReason.CACHE_OVERFLOW, DataCategory.Attachment, 1)
@@ -417,6 +421,98 @@ class ClientReportTest {
     assertEquals(envelope.items.first().data.size.toLong(), metricByteItem.quantity)
   }
 
+  @Test
+  fun `recording lost log item reads count from the header without deserializing the payload`() {
+    val onDiscardMock = mock<SentryOptions.OnDiscardCallback>()
+    givenClientReportRecorder { options -> options.onDiscard = onDiscardMock }
+
+    val payload = "irrelevant payload".toByteArray()
+    val item = mockEnvelopeItem(SentryItemType.Log, LOG_CONTENT_TYPE, itemCount = 5, data = payload)
+
+    clientReportRecorder.recordLostEnvelopeItem(DiscardReason.NETWORK_ERROR, item)
+
+    // Deserializing here is what pinned CPU cores under sustained rate limiting (JAVA-662), so the
+    // count must come from the header and the payload must stay untouched.
+    verify(item, never()).getLogs(any())
+    verify(onDiscardMock, times(1)).execute(DiscardReason.NETWORK_ERROR, DataCategory.LogItem, 5)
+
+    val clientReport = clientReportRecorder.resetCountsAndGenerateClientReport()
+    assertEquals(5, clientReport.quantityOf(DataCategory.LogItem))
+    assertEquals(payload.size.toLong(), clientReport.quantityOf(DataCategory.LogByte))
+  }
+
+  @Test
+  fun `recording lost metric item reads count from the header without deserializing the payload`() {
+    val onDiscardMock = mock<SentryOptions.OnDiscardCallback>()
+    givenClientReportRecorder { options -> options.onDiscard = onDiscardMock }
+
+    val payload = "irrelevant payload".toByteArray()
+    val item =
+      mockEnvelopeItem(
+        SentryItemType.TraceMetric,
+        METRIC_CONTENT_TYPE,
+        itemCount = 5,
+        data = payload,
+      )
+
+    clientReportRecorder.recordLostEnvelopeItem(DiscardReason.NETWORK_ERROR, item)
+
+    verify(item, never()).getMetrics(any())
+    verify(onDiscardMock, times(1))
+      .execute(DiscardReason.NETWORK_ERROR, DataCategory.TraceMetric, 5)
+
+    val clientReport = clientReportRecorder.resetCountsAndGenerateClientReport()
+    assertEquals(5, clientReport.quantityOf(DataCategory.TraceMetric))
+    assertEquals(payload.size.toLong(), clientReport.quantityOf(DataCategory.TraceMetricByte))
+  }
+
+  @Test
+  fun `recording lost log item without item count in header falls back to one`() {
+    givenClientReportRecorder()
+
+    val item =
+      mockEnvelopeItem(SentryItemType.Log, LOG_CONTENT_TYPE, itemCount = null, data = ByteArray(0))
+
+    clientReportRecorder.recordLostEnvelopeItem(DiscardReason.NETWORK_ERROR, item)
+
+    val clientReport = clientReportRecorder.resetCountsAndGenerateClientReport()
+    assertEquals(1, clientReport.quantityOf(DataCategory.LogItem))
+  }
+
+  @Test
+  fun `recording lost metric item without item count in header falls back to one`() {
+    givenClientReportRecorder()
+
+    val item =
+      mockEnvelopeItem(
+        SentryItemType.TraceMetric,
+        METRIC_CONTENT_TYPE,
+        itemCount = null,
+        data = ByteArray(0),
+      )
+
+    clientReportRecorder.recordLostEnvelopeItem(DiscardReason.NETWORK_ERROR, item)
+
+    val clientReport = clientReportRecorder.resetCountsAndGenerateClientReport()
+    assertEquals(1, clientReport.quantityOf(DataCategory.TraceMetric))
+  }
+
+  private fun mockEnvelopeItem(
+    type: SentryItemType,
+    contentType: String,
+    itemCount: Int?,
+    data: ByteArray,
+  ): SentryEnvelopeItem {
+    val itemHeader = SentryEnvelopeItemHeader(type, 0, contentType, null, null, null, itemCount)
+    return mock {
+      on { it.header } doReturn itemHeader
+      on { it.data } doReturn data
+    }
+  }
+
+  private fun ClientReport?.quantityOf(category: DataCategory): Long =
+    this!!.discardedEvents!!.first { it.category == category.category }.quantity
+
   private fun givenClientReportRecorder(
     callback: Sentry.OptionsConfiguration<SentryOptions>? = null
   ) {
@@ -470,9 +566,6 @@ class ClientReportTestHelper(val options: SentryOptions) {
     return SentryEnvelope(header, items.toList())
   }
 
-  fun toEnvelopeItem(clientReport: ClientReport): SentryEnvelopeItem =
-    SentryEnvelopeItem.fromClientReport(options.serializer, clientReport)
-
   companion object {
     fun retryableHint() = HintUtils.createWithTypeCheckHint(TestRetryable())
 

From 41d7c517f1d55d2054714c2abbd5813b0e32e0ef Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 30 Jul 2026 13:47:27 +0200
Subject: [PATCH 349/391] perf(core): Batch and coalesce scope-persistence disk
 writes (#5791)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* perf(core): Batch and coalesce scope-persistence disk writes (JAVA-628)

Scope persistence wrote to disk on every scope mutation, which dominated
SDK cost during startup: each breadcrumb triggered a synchronous fsync'd
QueueFile append, and every other scope field (contexts, trace, user,
tags, ...) rewrote its whole file on each change even though only the
latest value matters.

Coalesce mutations instead of writing eagerly. Each field keeps only its
latest pending value and is flushed once per debounce window; breadcrumbs
are buffered and appended together behind a single fsync (QueueFile gains
an opt-in buffered-write mode plus sync()). This trades a small data-loss
window (~100ms before the process dies) for far fewer writes and fsyncs.

Persistence exists to enrich crash/ANR events on the next launch, and was
already asynchronous, so the widened loss window is acceptable.

* Add changelog entry for #5791

* perf(core): Coalesce scope writes on submit instead of a timer (JAVA-628)

Scope-persistence flushes were debounced 100ms behind a scheduled task.
The debounce was unnecessary: the Sentry executor is single-threaded, so a
submitted flush task already sits in the queue long enough for mutations
arriving behind it to be folded into the same write. That is exactly the
window that matters, since the queue is deepest during startup.

Submit the flush instead of scheduling it. Coalescing now tracks executor
load rather than a fixed delay, which closes the data-loss window the
debounce introduced. Guard against the executor rejecting the task without
throwing once its queue is full, which would otherwise leave the pending
flag set and stop scope persistence for the rest of the process.

Also record why resetCache() deliberately leaves pending mutations alone:
they only ever hold values from the current process, so dropping them
would lose scope state set during init rather than clearing the previous
run's data.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(core): Keep breadcrumbs added during a scope flush (JAVA-628)

Batching split one ordered stream of breadcrumb operations into two
independent pieces of state: a queue of pending adds and a separate
clear flag. Independent state cannot preserve an ordering that the old
FIFO executor queue gave for free.

flushPending consumed the clear flag with a CAS at the top, then spent
the rest of the method serializing and writing each breadcrumb. A clear
plus a subsequent add landing in that window had its clear applied after
the new breadcrumb was already on disk, so the follow-up flush wiped a
breadcrumb that was added after the clear. Breadcrumbs are added from
arbitrary threads while the flush runs on the executor thread, so this
needs no unusual timing.

Enqueue the clear into the breadcrumb queue as a sentinel instead,
mirroring the DELETE_MARKER pattern already used for pendingWrites.
Ordering becomes intrinsic to the queue rather than something the flush
has to reconstruct. This also stops setBreadcrumbs(emptyList()) from
calling clear() on the shared queue, which could discard a breadcrumb
offered concurrently by another thread even with no flush in flight.

* docs(core): Clarify scope-persistence comments (JAVA-628)

"Durable" overstated what the buffered-write mode guarantees. sync()
issues an fsync, but durability also depends on the storage stack, so
describe what the code does — write to disk — rather than promise an
outcome it cannot ensure on its own.

Also name the pendingBreadcrumbs queue for what it holds: requests to
add and clear, not breadcrumbs already buffered.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* refactor(core): Fold the scope flush into one method (JAVA-628)

flushPending existed only so the @TestOnly flush() could do the disk
write without the latch bookkeeping that belongs to the queued task.
Nothing in production called flush(), and its only test asserted the
behaviour of flush() itself, so the second entry point was buying two
near-identical methods and a way to corrupt hasPendingFlush.

Drop flush() and merge the pair: flush() is now the queued task and
writePending() the write it performs. Clear hasPendingFlush in a finally
so an unexpected throw cannot leave the flag set, which would stop scope
persistence for the rest of the process.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* test(core): Drop redundant buffered-write QueueFile test (JAVA-628)

bufferedWritesSurviveReopenAfterSync was testAddOneElement with a second
element and a sync() call: same write, close, reopen, read-it-back shape,
and testAddAndRemoveElements already covers round-tripping far more
thoroughly.

The sync() it appeared to exercise was not actually load-bearing. close()
flushes through to the OS whichever mode the file was opened in, so the
assertions would hold even if sync() did nothing — the name promised
durability semantics the test could not verify in-process. Verifying that
would take a killed process, not a reopen.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* docs(core): Record that the vendored Tape fork has diverged (JAVA-628)

Square archived Tape on 2024-10-25, so the upstream link in each file
header points at a snapshot that will never receive fixes. Our copy has
also drifted from it: corruption recovery, a bounded ring size, and
optional buffered writes.

Say both things where a reader will look — the file headers, the class
javadoc, and THIRD_PARTY_NOTICES.md — so nobody diffs against upstream
expecting it to explain our behaviour, or files a bug there.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* refactor(core): Iterate pendingWrites directly when flushing (JAVA-628)

writePending() copied the key set into an ArrayList before draining it,
which allocates on every flush for no benefit: ConcurrentHashMap's
iterator is weakly consistent, so walking it while removing entries is
already safe.

Removal still goes through the map, not the iterator, because that is an
atomic get-and-remove — we never drop a value stored by a mutation racing
with the loop. Keys added after iteration starts can be missed, which is
fine since flush() re-checks and queues another write.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   2 +
 THIRD_PARTY_NOTICES.md                        |   4 +-
 sentry/api/sentry.api                         |   3 +
 .../sentry/cache/PersistingScopeObserver.java | 225 ++++++++++++------
 .../io/sentry/cache/tape/FileObjectQueue.java |   6 +
 .../io/sentry/cache/tape/ObjectQueue.java     |  13 +-
 .../java/io/sentry/cache/tape/QueueFile.java  |  77 ++++--
 .../PersistingScopeObserverBatchingTest.kt    | 132 ++++++++++
 .../io/sentry/cache/tape/QueueFileTest.kt     |   3 +-
 9 files changed, 372 insertions(+), 93 deletions(-)
 create mode 100644 sentry/src/test/java/io/sentry/cache/PersistingScopeObserverBatchingTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 89d412bcfdd..abb36b3089f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,8 @@
 
 - Remove an unused lock from `SentryPerformanceProvider`, which was allocated on every cold start in `ContentProvider.onCreate` without ever being acquired ([#5871](https://github.com/getsentry/sentry-java/pull/5871))
 - Parse the app start profiling config with only the deserializer it needs instead of building a full `JsonSerializer` and `SentryOptions`, cutting 188 of 221 allocations on the main thread before `Application.onCreate` ([#5867](https://github.com/getsentry/sentry-java/pull/5867))
+- Batch and coalesce scope-persistence disk writes to reduce startup cost ([#5791](https://github.com/getsentry/sentry-java/pull/5791))
+  - Scope mutations are now coalesced (latest value per field) and breadcrumbs are appended in batches behind a single fsync, instead of one synchronous disk write per mutation.
 
 ## 8.51.0
 
diff --git a/THIRD_PARTY_NOTICES.md b/THIRD_PARTY_NOTICES.md
index 381c39cfd68..a0040916145 100644
--- a/THIRD_PARTY_NOTICES.md
+++ b/THIRD_PARTY_NOTICES.md
@@ -136,7 +136,7 @@ limitations under the License.
 
 ## Square — Tape (Apache 2.0)
 
-**Source:** https://github.com/square/tape (Commit: 445cd3fd0a7b3ec48c9ea3e0e86663fe6d3735d8)<br>
+**Source:** https://github.com/square/tape (Commit: 445cd3fd0a7b3ec48c9ea3e0e86663fe6d3735d8, archived 2024-10-25)<br>
 **License:** Apache License 2.0<br>
 **Copyright:** Copyright (C) 2010 Square, Inc.
 
@@ -144,6 +144,8 @@ limitations under the License.
 
 The Sentry Java SDK includes an adapted version of Square's Tape library, a file-based FIFO queue implementation used for reliable event storage. The code resides in the `io.sentry.cache.tape` package and includes `QueueFile`, `FileObjectQueue`, and `ObjectQueue`.
 
+Upstream was archived on 2024-10-25 and is no longer maintained. This copy is maintained in-tree and has diverged from the linked commit: it recovers from file corruption by recreating the file, bounds the queue to a maximum number of elements, and supports optional buffered writes flushed by an explicit `sync()`.
+
 ```
 Copyright (C) 2010 Square, Inc.
 
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index e23f283d942..b807f70a88d 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -4934,6 +4934,7 @@ public abstract class io/sentry/cache/tape/ObjectQueue : java/io/Closeable, java
 	public fun remove ()V
 	public abstract fun remove (I)V
 	public abstract fun size ()I
+	public fun sync ()V
 }
 
 public abstract interface class io/sentry/cache/tape/ObjectQueue$Converter {
@@ -4954,6 +4955,7 @@ public final class io/sentry/cache/tape/QueueFile : java/io/Closeable, java/lang
 	public fun remove ()V
 	public fun remove (I)V
 	public fun size ()I
+	public fun sync ()V
 	public fun toString ()Ljava/lang/String;
 }
 
@@ -4961,6 +4963,7 @@ public final class io/sentry/cache/tape/QueueFile$Builder {
 	public fun <init> (Ljava/io/File;)V
 	public fun build ()Lio/sentry/cache/tape/QueueFile;
 	public fun size (I)Lio/sentry/cache/tape/QueueFile$Builder;
+	public fun synchronousWrites (Z)Lio/sentry/cache/tape/QueueFile$Builder;
 	public fun zero (Z)Lio/sentry/cache/tape/QueueFile$Builder;
 }
 
diff --git a/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java b/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
index 420d0d31e22..d6137ae051a 100644
--- a/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
+++ b/sentry/src/main/java/io/sentry/cache/PersistingScopeObserver.java
@@ -7,7 +7,6 @@
 import io.sentry.Breadcrumb;
 import io.sentry.IScope;
 import io.sentry.ScopeObserverAdapter;
-import io.sentry.SentryExecutorService;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
 import io.sentry.SpanContext;
@@ -30,7 +29,13 @@
 import java.io.Writer;
 import java.nio.charset.Charset;
 import java.util.Collection;
+import java.util.Iterator;
 import java.util.Map;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicBoolean;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -38,6 +43,12 @@ public final class PersistingScopeObserver extends ScopeObserverAdapter {
 
   private static final Charset UTF_8 = Charset.forName("UTF-8");
 
+  /** Sentinel value marking a file that should be deleted rather than written on the next flush. */
+  private static final Object DELETE_MARKER = new Object();
+
+  /** Sentinel value marking a breadcrumb clear in the pending breadcrumb operations. */
+  private static final Object CLEAR_MARKER = new Object();
+
   public static final String SCOPE_CACHE = ".scope-cache";
   public static final String USER_FILENAME = "user.json";
   public static final String BREADCRUMBS_FILENAME = "breadcrumbs.json";
@@ -65,7 +76,11 @@ public final class PersistingScopeObserver extends ScopeObserverAdapter {
             final File file = new File(cacheDir, BREADCRUMBS_FILENAME);
             try {
               try {
-                queueFile = new QueueFile.Builder(file).size(options.getMaxBreadcrumbs()).build();
+                queueFile =
+                    new QueueFile.Builder(file)
+                        .size(options.getMaxBreadcrumbs())
+                        .synchronousWrites(false)
+                        .build();
               } catch (IOException e) {
                 // if file is corrupted we simply delete it and try to create it again. We accept
                 // the trade
@@ -74,7 +89,11 @@ public final class PersistingScopeObserver extends ScopeObserverAdapter {
                 // update where the new format was introduced
                 file.delete();
 
-                queueFile = new QueueFile.Builder(file).size(options.getMaxBreadcrumbs()).build();
+                queueFile =
+                    new QueueFile.Builder(file)
+                        .size(options.getMaxBreadcrumbs())
+                        .synchronousWrites(false)
+                        .build();
               }
             } catch (IOException e) {
               options.getLogger().log(ERROR, "Failed to create breadcrumbs queue", e);
@@ -106,32 +125,30 @@ public void toStream(Breadcrumb value, OutputStream sink) throws IOException {
                 });
           });
 
+  // Latest pending value per file (or DELETE_MARKER), coalesced until the next flush.
+  private final @NotNull Map<String, Object> pendingWrites = new ConcurrentHashMap<>();
+  // Tracks requests to add and clear breadcrumb since the last flush, applied together behind a
+  // single fsync. Adds and clears share one queue so their relative order survives batching:
+  // a clear must not wipe a breadcrumb added after it.
+  private final @NotNull Queue<Object> pendingBreadcrumbs = new ConcurrentLinkedQueue<>();
+  private final @NotNull AtomicBoolean hasPendingFlush = new AtomicBoolean(false);
+
   public PersistingScopeObserver(final @NotNull SentryOptions options) {
     this.options = options;
   }
 
   @Override
   public void setUser(final @Nullable User user) {
-    serializeToDisk(
-        () -> {
-          if (user == null) {
-            delete(USER_FILENAME);
-          } else {
-            store(user, USER_FILENAME);
-          }
-        });
+    enqueue(USER_FILENAME, user);
   }
 
   @Override
   public void addBreadcrumb(@NotNull Breadcrumb crumb) {
-    serializeToDisk(
-        () -> {
-          try {
-            breadcrumbsQueue.getValue().add(crumb);
-          } catch (IOException e) {
-            options.getLogger().log(ERROR, "Failed to add breadcrumb to file queue", e);
-          }
-        });
+    if (!options.isEnableScopePersistence()) {
+      return;
+    }
+    pendingBreadcrumbs.offer(crumb);
+    requestFlush();
   }
 
   @Override
@@ -139,107 +156,159 @@ public void setBreadcrumbs(@NotNull Collection<Breadcrumb> breadcrumbs) {
     if (breadcrumbs.isEmpty()) {
       // we only clear the queue if the new collection is empty (someone called clearBreadcrumbs)
       // If it's not empty, we'd add breadcrumbs one-by-one in the method above
-      serializeToDisk(
-          () -> {
-            try {
-              breadcrumbsQueue.getValue().clear();
-            } catch (IOException e) {
-              options.getLogger().log(ERROR, "Failed to clear breadcrumbs from file queue", e);
-            }
-          });
+      if (!options.isEnableScopePersistence()) {
+        return;
+      }
+      pendingBreadcrumbs.offer(CLEAR_MARKER);
+      requestFlush();
     }
   }
 
   @Override
   public void setTags(@NotNull Map<String, @NotNull String> tags) {
-    serializeToDisk(() -> store(tags, TAGS_FILENAME));
+    enqueue(TAGS_FILENAME, tags);
   }
 
   @Override
   public void setExtras(@NotNull Map<String, @NotNull Object> extras) {
-    serializeToDisk(() -> store(extras, EXTRAS_FILENAME));
+    enqueue(EXTRAS_FILENAME, extras);
   }
 
   @Override
   public void setRequest(@Nullable Request request) {
-    serializeToDisk(
-        () -> {
-          if (request == null) {
-            delete(REQUEST_FILENAME);
-          } else {
-            store(request, REQUEST_FILENAME);
-          }
-        });
+    enqueue(REQUEST_FILENAME, request);
   }
 
   @Override
   public void setFingerprint(@NotNull Collection<String> fingerprint) {
-    serializeToDisk(() -> store(fingerprint, FINGERPRINT_FILENAME));
+    enqueue(FINGERPRINT_FILENAME, fingerprint);
   }
 
   @Override
   public void setLevel(@Nullable SentryLevel level) {
-    serializeToDisk(
-        () -> {
-          if (level == null) {
-            delete(LEVEL_FILENAME);
-          } else {
-            store(level, LEVEL_FILENAME);
-          }
-        });
+    enqueue(LEVEL_FILENAME, level);
   }
 
   @Override
   public void setTransaction(@Nullable String transaction) {
-    serializeToDisk(
-        () -> {
-          if (transaction == null) {
-            delete(TRANSACTION_FILENAME);
-          } else {
-            store(transaction, TRANSACTION_FILENAME);
-          }
-        });
+    enqueue(TRANSACTION_FILENAME, transaction);
   }
 
   @Override
   public void setTrace(@Nullable SpanContext spanContext, @NotNull IScope scope) {
-    serializeToDisk(
-        () -> {
-          if (spanContext == null) {
-            // we always need a trace_id to properly link with traces/replays, so we fallback to
-            // propagation context values and create a fake SpanContext
-            store(scope.getPropagationContext().toSpanContext(), TRACE_FILENAME);
-          } else {
-            store(spanContext, TRACE_FILENAME);
-          }
-        });
+    // we always need a trace_id to properly link with traces/replays, so we fallback to
+    // propagation context values and create a fake SpanContext
+    enqueue(
+        TRACE_FILENAME,
+        spanContext == null ? scope.getPropagationContext().toSpanContext() : spanContext);
   }
 
   @Override
   public void setContexts(@NotNull Contexts contexts) {
-    serializeToDisk(() -> store(contexts, CONTEXTS_FILENAME));
+    enqueue(CONTEXTS_FILENAME, contexts);
   }
 
   @Override
   public void setReplayId(@NotNull SentryId replayId) {
-    serializeToDisk(() -> store(replayId, REPLAY_FILENAME));
+    enqueue(REPLAY_FILENAME, replayId);
   }
 
-  @SuppressWarnings("FutureReturnValueIgnored")
-  private void serializeToDisk(final @NotNull Runnable task) {
+  private void enqueue(final @NotNull String fileName, final @Nullable Object entity) {
     if (!options.isEnableScopePersistence()) {
       return;
     }
-    if (SentryExecutorService.isSentryExecutorThread()) {
-      // we're already on the sentry executor thread, so we can just execute it directly
-      runSafely(task);
+    // latest value wins; a null entity means the file should be deleted on the next flush
+    pendingWrites.put(fileName, entity == null ? DELETE_MARKER : entity);
+    requestFlush();
+  }
+
+  /**
+   * Queues a flush unless one is already queued. Coalescing comes from the flush task sitting in
+   * the executor queue: every mutation that arrives before it runs is folded into the same write.
+   * The executor is single-threaded, so during startup — when mutations are frequent and the queue
+   * is deep — that window covers many mutations.
+   */
+  private void requestFlush() {
+    if (!hasPendingFlush.compareAndSet(false, true)) {
+      // a flush is already queued; it will pick up the latest pending state
       return;
     }
-
     try {
-      options.getExecutorService().submit(() -> runSafely(task));
+      final @NotNull Future<?> future = options.getExecutorService().submit(this::flush);
+      if (future.isCancelled()) {
+        // the executor rejects tasks without throwing once its queue is full, so clear the flag or
+        // no later mutation would ever be able to queue a flush again
+        hasPendingFlush.set(false);
+      }
     } catch (Throwable e) {
-      options.getLogger().log(ERROR, "Serialization task could not be scheduled", e);
+      hasPendingFlush.set(false);
+      options.getLogger().log(ERROR, "Scope persistence flush could not be submitted", e);
+    }
+  }
+
+  /**
+   * Writes all coalesced scope state to disk. Runs as the queued flush task on the Sentry executor,
+   * which is also the only place it may run: it does I/O, and it owns clearing {@link
+   * #hasPendingFlush} once the write is done.
+   */
+  private void flush() {
+    try {
+      runSafely(this::writePending);
+    } finally {
+      // clear the flag before re-checking, otherwise a mutation landing between the drain and the
+      // clear would see a flush still queued and be left with nobody to write it. In a finally so
+      // an unexpected throw can't leave the flag set and stop persistence for the whole process.
+      hasPendingFlush.set(false);
+      if (!pendingWrites.isEmpty() || !pendingBreadcrumbs.isEmpty()) {
+        requestFlush();
+      }
+    }
+  }
+
+  private void writePending() {
+    // ConcurrentHashMap's iterator is weakly consistent, so removing while iterating is safe. Keys
+    // added after iteration starts may be missed, but flush() re-checks and queues another write.
+    // We remove through the map rather than the iterator: that is an atomic get-and-remove, so we
+    // never drop a value written by a mutation racing with this loop.
+    final @NotNull Iterator<String> fileNames = pendingWrites.keySet().iterator();
+    while (fileNames.hasNext()) {
+      final @NotNull String fileName = fileNames.next();
+      final @Nullable Object entity = pendingWrites.remove(fileName);
+      if (entity == null) {
+        // removed by a concurrent flush
+        continue;
+      }
+      if (entity == DELETE_MARKER) {
+        delete(fileName);
+      } else {
+        store(entity, fileName);
+      }
+    }
+
+    boolean breadcrumbsChanged = false;
+    final @NotNull ObjectQueue<Breadcrumb> queue = breadcrumbsQueue.getValue();
+
+    Object operation;
+    while ((operation = pendingBreadcrumbs.poll()) != null) {
+      try {
+        if (operation == CLEAR_MARKER) {
+          queue.clear();
+        } else {
+          queue.add((Breadcrumb) operation);
+        }
+        breadcrumbsChanged = true;
+      } catch (IOException e) {
+        options.getLogger().log(ERROR, "Failed to apply breadcrumb change to file queue", e);
+      }
+    }
+
+    if (breadcrumbsChanged) {
+      try {
+        // single fsync for the whole batch instead of one per breadcrumb
+        queue.sync();
+      } catch (IOException e) {
+        options.getLogger().log(ERROR, "Failed to sync breadcrumbs file queue", e);
+      }
     }
   }
 
@@ -286,9 +355,15 @@ public static <T> void store(
    * I/O and should be called from a background thread.
    */
   public void resetCache() {
+    // NOTE: pending mutations are deliberately left alone. They only ever hold values from the
+    // current process, which is exactly what this reset is clearing the way for; dropping them
+    // would lose scope state set during init.
     // since it keeps a reference to the file and we cannot delete it, breadcrumbs we just clear
     try {
-      breadcrumbsQueue.getValue().clear();
+      final @NotNull ObjectQueue<Breadcrumb> queue = breadcrumbsQueue.getValue();
+      queue.clear();
+      // breadcrumbs use buffered writes, so make the clear durable explicitly
+      queue.sync();
     } catch (IOException e) {
       options.getLogger().log(ERROR, "Failed to clear breadcrumbs from file queue", e);
     }
diff --git a/sentry/src/main/java/io/sentry/cache/tape/FileObjectQueue.java b/sentry/src/main/java/io/sentry/cache/tape/FileObjectQueue.java
index 31b111e03ad..d4a70f9c179 100644
--- a/sentry/src/main/java/io/sentry/cache/tape/FileObjectQueue.java
+++ b/sentry/src/main/java/io/sentry/cache/tape/FileObjectQueue.java
@@ -1,5 +1,6 @@
 /*
  * Adapted from: https://github.com/square/tape/tree/445cd3fd0a7b3ec48c9ea3e0e86663fe6d3735d8/tape/src/main/java/com/squareup/tape2
+ * Upstream was archived on 2024-10-25 and receives no further fixes; this copy has local changes.
  *
  *  Copyright (C) 2010 Square, Inc.
  *
@@ -59,6 +60,11 @@ public void add(T entry) throws IOException {
     queueFile.add(bytes.getArray(), 0, bytes.size());
   }
 
+  @Override
+  public void sync() throws IOException {
+    queueFile.sync();
+  }
+
   @Override
   public @Nullable T peek() throws IOException {
     byte[] bytes = queueFile.peek();
diff --git a/sentry/src/main/java/io/sentry/cache/tape/ObjectQueue.java b/sentry/src/main/java/io/sentry/cache/tape/ObjectQueue.java
index c92cad36218..40f3b71bbdf 100644
--- a/sentry/src/main/java/io/sentry/cache/tape/ObjectQueue.java
+++ b/sentry/src/main/java/io/sentry/cache/tape/ObjectQueue.java
@@ -1,5 +1,6 @@
 /*
  * Adapted from: https://github.com/square/tape/tree/445cd3fd0a7b3ec48c9ea3e0e86663fe6d3735d8/tape/src/main/java/com/squareup/tape2
+ * Upstream was archived on 2024-10-25 and receives no further fixes; this copy has local changes.
  *
  *  Copyright (C) 2010 Square, Inc.
  *
@@ -30,7 +31,11 @@
 /** A queue of objects. */
 @ApiStatus.Internal
 public abstract class ObjectQueue<T> implements Iterable<T>, Closeable {
-  /** A queue for objects that are atomically and durably serialized to {@code file}. */
+  /**
+   * A queue for objects that are atomically and durably serialized to {@code file}. Durability
+   * depends on {@code qf}: a {@link QueueFile} built with buffered writes only becomes durable on
+   * {@link #sync()}.
+   */
   public static <T> ObjectQueue<T> create(QueueFile qf, Converter<T> converter) {
     return new FileObjectQueue<>(qf, converter);
   }
@@ -54,6 +59,12 @@ public boolean isEmpty() {
   /** Enqueues an entry that can be processed at any time. */
   public abstract void add(T entry) throws IOException;
 
+  /**
+   * Flushes any buffered writes to storage. No-op for queues that already write synchronously or
+   * are purely in-memory.
+   */
+  public void sync() throws IOException {}
+
   /**
    * Returns the head of the queue, or {@code null} if the queue is empty. Does not modify the
    * queue.
diff --git a/sentry/src/main/java/io/sentry/cache/tape/QueueFile.java b/sentry/src/main/java/io/sentry/cache/tape/QueueFile.java
index bc2ed568267..137f1cd9156 100644
--- a/sentry/src/main/java/io/sentry/cache/tape/QueueFile.java
+++ b/sentry/src/main/java/io/sentry/cache/tape/QueueFile.java
@@ -1,5 +1,6 @@
 /*
  * Adapted from: https://github.com/square/tape/tree/445cd3fd0a7b3ec48c9ea3e0e86663fe6d3735d8/tape/src/main/java/com/squareup/tape2
+ * Upstream was archived on 2024-10-25 and receives no further fixes; this copy has local changes.
  *
  *  Copyright (C) 2010 Square, Inc.
  *
@@ -33,12 +34,19 @@
 import org.jetbrains.annotations.Nullable;
 
 /**
- * A reliable, efficient, file-based, FIFO queue. Additions and removals are O(1). All operations
- * are atomic. Writes are synchronous; data will be written to disk before an operation returns. The
- * underlying file is structured to survive process and even system crashes. If an I/O exception is
- * thrown during a mutating change, the change is aborted. It is safe to continue to use a {@code
+ * A reliable, efficient, file-based, FIFO queue. Additions and removals are O(1). The underlying
+ * file is structured to survive process and even system crashes. If an I/O exception is thrown
+ * during a mutating change, the change is aborted. It is safe to continue to use a {@code
  * QueueFile} instance after an exception.
  *
+ * <p>By default all operations are atomic and writes are synchronous: data is on disk before an
+ * operation returns. Queues built with {@link Builder#synchronousWrites(boolean)
+ * synchronousWrites(false)} leave writes in the OS page cache until {@link #sync()} is called,
+ * which lets callers batch many mutations behind a single fsync. Such writes still survive process
+ * death and are immediately visible to readers, but a system crash before the next {@code sync()}
+ * can lose recent mutations — and because the OS may flush the data and header pages in either
+ * order, it can leave a committed header pointing at data that never reached disk.
+ *
  * <p><strong>Note that this implementation is not synchronized.</strong>
  *
  * <p>In a traditional queue, the remove operation returns an element. In this queue, {@link #peek}
@@ -50,10 +58,17 @@
  * <p><strong>NOTE:</strong> The current implementation is built for file systems that support
  * atomic segment writes (like YAFFS). Most conventional file systems don't support this; if the
  * power goes out while writing a segment, the segment will contain garbage and the file will be
- * corrupt. We'll add journaling support so this class can be used with more file systems later.
+ * corrupt. Upstream intended to add journaling support for those file systems but never did; this
+ * fork instead accepts the risk and recovers by deleting and recreating the file, losing its
+ * contents (see {@code ringRead}).
  *
  * <p>Construct instances with {@link Builder}.
  *
+ * <p><strong>This is a vendored fork.</strong> Square archived Tape on 2024-10-25, so the upstream
+ * link in the header is a historical reference, not a source of fixes. This copy has diverged:
+ * corruption recovery, a bounded ring size, and optional buffered writes. Report problems against
+ * sentry-java rather than upstream.
+ *
  * @author Bob Lee (bob@squareup.com)
  */
 @ApiStatus.Internal
@@ -130,13 +145,22 @@ public final class QueueFile implements Closeable, Iterable<byte[]> {
   /** A number of elements at which this queue will wrap around (ring buffer). */
   private final int maxElements;
 
+  /**
+   * When {@code false}, writes are buffered by the OS and callers must call {@link #sync()} to
+   * write to disk. This lets callers batch many adds behind a single fsync instead of paying one
+   * fsync per write.
+   */
+  private final boolean synchronousWrites;
+
   boolean closed;
 
-  static RandomAccessFile initializeFromFile(File file) throws IOException {
+  static RandomAccessFile initializeFromFile(File file, boolean synchronousWrites)
+      throws IOException {
     if (!file.exists()) {
       // Use a temp file so we don't leave a partially-initialized file.
       File tempFile = new File(file.getPath() + ".tmp");
-      RandomAccessFile raf = open(tempFile);
+      // The one-time initialization is always synchronous so the header is written before rename.
+      RandomAccessFile raf = open(tempFile, true);
       try {
         raf.setLength(INITIAL_LENGTH);
         raf.seek(0);
@@ -152,23 +176,36 @@ static RandomAccessFile initializeFromFile(File file) throws IOException {
       }
     }
 
-    return open(file);
+    return open(file, synchronousWrites);
   }
 
-  /** Opens a random access file that writes synchronously. */
-  private static RandomAccessFile open(File file) throws FileNotFoundException {
-    return new RandomAccessFile(file, "rwd");
+  private static RandomAccessFile open(File file, boolean synchronousWrites)
+      throws FileNotFoundException {
+    return new RandomAccessFile(file, synchronousWrites ? "rwd" : "rw");
   }
 
-  QueueFile(File file, RandomAccessFile raf, boolean zero, int maxElements) throws IOException {
+  QueueFile(
+      File file, RandomAccessFile raf, boolean zero, int maxElements, boolean synchronousWrites)
+      throws IOException {
     this.file = file;
     this.raf = raf;
     this.zero = zero;
     this.maxElements = maxElements;
+    this.synchronousWrites = synchronousWrites;
 
     readInitialData();
   }
 
+  /**
+   * Flushes buffered writes to storage. No-op when the queue was opened with synchronous writes,
+   * since those are already durable.
+   */
+  public void sync() throws IOException {
+    if (!synchronousWrites) {
+      raf.getChannel().force(false);
+    }
+  }
+
   private void readInitialData() throws IOException {
     raf.seek(0);
     raf.readFully(buffer);
@@ -196,7 +233,7 @@ private void readInitialData() throws IOException {
   private void resetFile() throws IOException {
     raf.close();
     file.delete();
-    raf = initializeFromFile(file);
+    raf = initializeFromFile(file, synchronousWrites);
     readInitialData();
   }
 
@@ -767,6 +804,7 @@ public static final class Builder {
     final File file;
     boolean zero = true;
     int size = -1;
+    boolean synchronousWrites = true;
 
     /** Start constructing a new queue backed by the given file. */
     public Builder(File file) {
@@ -788,15 +826,24 @@ public Builder size(int size) {
       return this;
     }
 
+    /**
+     * When {@code false}, writes are buffered and the caller must call {@link QueueFile#sync()} to
+     * write to disk. Defaults to {@code true} (every write is fsync'd).
+     */
+    public Builder synchronousWrites(boolean synchronousWrites) {
+      this.synchronousWrites = synchronousWrites;
+      return this;
+    }
+
     /**
      * Constructs a new queue backed by the given builder. Only one instance should access a given
      * file at a time.
      */
     public QueueFile build() throws IOException {
-      RandomAccessFile raf = initializeFromFile(file);
+      RandomAccessFile raf = initializeFromFile(file, synchronousWrites);
       QueueFile qf = null;
       try {
-        qf = new QueueFile(file, raf, zero, size);
+        qf = new QueueFile(file, raf, zero, size, synchronousWrites);
         return qf;
       } finally {
         if (qf == null) {
diff --git a/sentry/src/test/java/io/sentry/cache/PersistingScopeObserverBatchingTest.kt b/sentry/src/test/java/io/sentry/cache/PersistingScopeObserverBatchingTest.kt
new file mode 100644
index 00000000000..eec38e151ee
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/cache/PersistingScopeObserverBatchingTest.kt
@@ -0,0 +1,132 @@
+package io.sentry.cache
+
+import com.google.common.truth.Truth.assertThat
+import io.sentry.Breadcrumb
+import io.sentry.ISentryExecutorService
+import io.sentry.ISerializer
+import io.sentry.SentryOptions
+import io.sentry.cache.PersistingScopeObserver.BREADCRUMBS_FILENAME
+import io.sentry.cache.PersistingScopeObserver.TRANSACTION_FILENAME
+import io.sentry.test.DeferredExecutorService
+import java.io.Writer
+import java.util.concurrent.atomic.AtomicBoolean
+import kotlin.test.Test
+import org.junit.Rule
+import org.junit.rules.TemporaryFolder
+
+class PersistingScopeObserverBatchingTest {
+  @get:Rule val tmpDir = TemporaryFolder()
+
+  private val options = SentryOptions()
+
+  private fun getSut(executor: ISentryExecutorService): PersistingScopeObserver {
+    options.executorService = executor
+    options.cacheDirPath = tmpDir.newFolder().absolutePath
+    return PersistingScopeObserver(options)
+  }
+
+  private fun PersistingScopeObserver.readTransaction(): String? =
+    read(options, TRANSACTION_FILENAME, String::class.java)
+
+  @Suppress("UNCHECKED_CAST")
+  private fun PersistingScopeObserver.readBreadcrumbs(): List<Breadcrumb> =
+    read(options, BREADCRUMBS_FILENAME, List::class.java) as List<Breadcrumb>
+
+  @Test
+  fun `defers writes until the flush runs`() {
+    val executor = DeferredExecutorService()
+    val sut = getSut(executor)
+
+    sut.setTransaction("MainActivity")
+    assertThat(sut.readTransaction()).isNull()
+
+    executor.runAll()
+    assertThat(sut.readTransaction()).isEqualTo("MainActivity")
+  }
+
+  @Test
+  fun `coalesces repeated writes keeping only the latest value`() {
+    val executor = DeferredExecutorService()
+    val sut = getSut(executor)
+
+    sut.setTransaction("A")
+    sut.setTransaction("B")
+    sut.setTransaction("C")
+    executor.runAll()
+
+    assertThat(sut.readTransaction()).isEqualTo("C")
+  }
+
+  @Test
+  fun `batches breadcrumbs and persists all of them`() {
+    val executor = DeferredExecutorService()
+    val sut = getSut(executor)
+
+    sut.addBreadcrumb(Breadcrumb().apply { message = "one" })
+    sut.addBreadcrumb(Breadcrumb().apply { message = "two" })
+    assertThat(sut.readBreadcrumbs()).isEmpty()
+
+    executor.runAll()
+    assertThat(sut.readBreadcrumbs().map { it.message }).containsExactly("one", "two").inOrder()
+  }
+
+  @Test
+  fun `clearing breadcrumbs drops earlier pending adds but keeps later ones`() {
+    val executor = DeferredExecutorService()
+    val sut = getSut(executor)
+
+    sut.addBreadcrumb(Breadcrumb().apply { message = "dropped" })
+    sut.setBreadcrumbs(emptyList())
+    sut.addBreadcrumb(Breadcrumb().apply { message = "kept" })
+    executor.runAll()
+
+    assertThat(sut.readBreadcrumbs().map { it.message }).containsExactly("kept")
+  }
+
+  @Test
+  fun `a clear landing mid-flush does not wipe breadcrumbs added after it`() {
+    val executor = DeferredExecutorService()
+    lateinit var sut: PersistingScopeObserver
+    // fires while the flush is draining, i.e. after the first breadcrumb has been written
+    options.setSerializer(
+      SerializerHook(options.serializer) {
+        sut.setBreadcrumbs(emptyList())
+        sut.addBreadcrumb(Breadcrumb().apply { message = "kept" })
+      }
+    )
+    sut = getSut(executor)
+
+    sut.addBreadcrumb(Breadcrumb().apply { message = "dropped" })
+    executor.runAll()
+    executor.runAll()
+
+    assertThat(sut.readBreadcrumbs().map { it.message }).containsExactly("kept")
+  }
+
+  /** Delegates to [delegate], running [onFirstBreadcrumb] once, mid-serialization. */
+  private class SerializerHook(
+    private val delegate: ISerializer,
+    private val onFirstBreadcrumb: () -> Unit,
+  ) : ISerializer by delegate {
+    private val fired = AtomicBoolean(false)
+
+    override fun <T : Any> serialize(entity: T, writer: Writer) {
+      if (entity is Breadcrumb && fired.compareAndSet(false, true)) {
+        onFirstBreadcrumb()
+      }
+      delegate.serialize(entity, writer)
+    }
+  }
+
+  @Test
+  fun `resetCache keeps pending mutations from the current process`() {
+    val executor = DeferredExecutorService()
+    val sut = getSut(executor)
+
+    sut.setTransaction("SetDuringInit")
+    sut.resetCache()
+    executor.runAll()
+
+    assertThat(sut.readTransaction()).isEqualTo("SetDuringInit")
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/cache/tape/QueueFileTest.kt b/sentry/src/test/java/io/sentry/cache/tape/QueueFileTest.kt
index c909b48a9b3..faa2b2e0ba4 100644
--- a/sentry/src/test/java/io/sentry/cache/tape/QueueFileTest.kt
+++ b/sentry/src/test/java/io/sentry/cache/tape/QueueFileTest.kt
@@ -49,7 +49,8 @@ class QueueFileTest {
   @get:Rule val folder = TemporaryFolder()
   private lateinit var file: File
 
-  private fun newQueueFile(raf: RandomAccessFile): QueueFile = QueueFile(this.file, raf, true, -1)
+  private fun newQueueFile(raf: RandomAccessFile): QueueFile =
+    QueueFile(this.file, raf, true, -1, true)
 
   private fun newQueueFile(zero: Boolean = true, size: Int = -1): QueueFile =
     Builder(file).zero(zero).size(size).build()

From 6de396216e98feeedacf3bd83621a6de53e7cb2e Mon Sep 17 00:00:00 2001
From: Alexander <alex@apantiukhov.com>
Date: Thu, 30 Jul 2026 14:01:53 +0200
Subject: [PATCH 350/391] fix(android): Drop inflated app start for
 background-spawned processes on API 35+ (#5841)

* fix(android): Drop inflated app start for background-spawned processes on API 35+

When the OS spawns the process for background work (FCM push, job, service,
broadcast, etc.) and the user opens the app later, the app start stayed anchored
at background process creation, inflating the reported cold start by the whole
idle gap.

On API 35+ we now use ApplicationStartInfo.getReason() to detect background
process starts and mark them as not launched in foreground, so the first created
activity re-classifies them as a warm start anchored at activity creation.

* docs: fix changelog PR link

* docs: trim code comments

* docs: trim changelog entry

* Update Changelog

* Reverse isBackgroundStartReason to isForegroundStartReason

* Add extra test

---------

Co-authored-by: Markus Hintersteiner <markus.hintersteiner@sentry.io>
---
 CHANGELOG.md                                  |   1 +
 .../core/performance/AppStartMetrics.java     |  31 +++++
 .../performance/AppStartMetricsTestApi35.kt   | 112 ++++++++++++++++++
 3 files changed, 144 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index abb36b3089f..d826db437c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Prevent inflated cold app start when the OS spawns the process in the background (e.g. FCM push) on API 35+ ([#5841](https://github.com/getsentry/sentry-java/pull/5841))
 - Avoid a CPU busy-loop when recording discarded log or metric envelopes under rate limiting ([#5835](https://github.com/getsentry/sentry-java/pull/5835))
   - `ClientReportRecorder` now reads the item count from the envelope item header instead of deserializing the payload, which under sustained rate limiting could pin CPU cores while repeatedly throwing exceptions
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
index 0f4b646856a..97f5c5fd6ec 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
@@ -14,6 +14,7 @@
 import android.util.Log;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
 import androidx.annotation.VisibleForTesting;
 import io.sentry.IContinuousProfiler;
 import io.sentry.ISentryLifecycleToken;
@@ -208,6 +209,35 @@ public void setAppStartType(final @NotNull AppStartType appStartType) {
     }
   }
 
+  /**
+   * Whether {@link ApplicationStartInfo#getReason()} indicates the OS spawned the app process
+   * because of an intentional user interaction.
+   *
+   * @return true if the user actively launched the app, false if the app was launched in
+   *     background, and null if unknown.
+   */
+  @RequiresApi(api = Build.VERSION_CODES.VANILLA_ICE_CREAM)
+  private static @Nullable Boolean isForegroundStartReason(final int reason) {
+    switch (reason) {
+      case ApplicationStartInfo.START_REASON_LAUNCHER:
+      case ApplicationStartInfo.START_REASON_LAUNCHER_RECENTS:
+      case ApplicationStartInfo.START_REASON_START_ACTIVITY:
+        return true;
+      case ApplicationStartInfo.START_REASON_ALARM:
+      case ApplicationStartInfo.START_REASON_BACKUP:
+      case ApplicationStartInfo.START_REASON_BOOT_COMPLETE:
+      case ApplicationStartInfo.START_REASON_BROADCAST:
+      case ApplicationStartInfo.START_REASON_CONTENT_PROVIDER:
+      case ApplicationStartInfo.START_REASON_JOB:
+      case ApplicationStartInfo.START_REASON_PUSH:
+      case ApplicationStartInfo.START_REASON_SERVICE:
+        return false;
+      case ApplicationStartInfo.START_REASON_OTHER:
+      default:
+        return null;
+    }
+  }
+
   public boolean isAppLaunchedInForeground() {
     return appLaunchedInForeground.getValue();
   }
@@ -499,6 +529,7 @@ public void registerLifecycleCallbacks(final @NotNull Application application) {
               } else {
                 appStartType = AppStartType.WARM;
               }
+              appLaunchedInForeground.setValue(isForegroundStartReason(info.getReason()));
             }
           }
         } catch (RuntimeException ignored) {
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
index 0624e70b898..a7eace97371 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTestApi35.kt
@@ -1,11 +1,13 @@
 package io.sentry.android.core.performance
 
+import android.app.Activity
 import android.app.ActivityManager.RunningAppProcessInfo
 import android.app.Application
 import android.app.ApplicationStartInfo
 import android.os.Build
 import android.os.Handler
 import android.os.Looper
+import android.os.SystemClock
 import androidx.test.core.app.ApplicationProvider
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import io.sentry.android.core.SentryShadowActivityManager
@@ -16,6 +18,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNull
+import kotlin.test.assertTrue
 import org.junit.Before
 import org.junit.runner.RunWith
 import org.mockito.kotlin.mock
@@ -263,6 +266,115 @@ class AppStartMetricsTestApi35 {
     assertNull(metrics.appStartReason)
   }
 
+  @Test
+  fun `background start reason marks app as not launched in foreground`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    whenever(mockStartInfo.reason).thenReturn(ApplicationStartInfo.START_REASON_PUSH)
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    val metrics = AppStartMetrics.getInstance()
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    assertFalse(metrics.isAppLaunchedInForeground)
+  }
+
+  @Test
+  fun `all background start reasons mark app as not launched in foreground`() {
+    val backgroundReasons =
+      listOf(
+        ApplicationStartInfo.START_REASON_ALARM,
+        ApplicationStartInfo.START_REASON_BACKUP,
+        ApplicationStartInfo.START_REASON_BOOT_COMPLETE,
+        ApplicationStartInfo.START_REASON_BROADCAST,
+        ApplicationStartInfo.START_REASON_CONTENT_PROVIDER,
+        ApplicationStartInfo.START_REASON_JOB,
+        ApplicationStartInfo.START_REASON_PUSH,
+        ApplicationStartInfo.START_REASON_SERVICE,
+      )
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    for (reason in backgroundReasons) {
+      AppStartMetrics.getInstance().clear()
+      SentryShadowActivityManager.reset()
+
+      val mockStartInfo = mock<ApplicationStartInfo>()
+      whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+      whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+      whenever(mockStartInfo.reason).thenReturn(reason)
+      SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+
+      AppStartMetrics.getInstance().registerLifecycleCallbacks(app)
+
+      assertFalse(
+        AppStartMetrics.getInstance().isAppLaunchedInForeground,
+        "reason $reason should not be launched in foreground",
+      )
+    }
+  }
+
+  @Test
+  fun `user-initiated start reason keeps app launched in foreground`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    whenever(mockStartInfo.reason).thenReturn(ApplicationStartInfo.START_REASON_LAUNCHER)
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    SentryShadowActivityManager.setImportance(RunningAppProcessInfo.IMPORTANCE_FOREGROUND)
+    val metrics = AppStartMetrics.getInstance()
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    assertTrue(metrics.isAppLaunchedInForeground)
+  }
+
+  @Test
+  fun `unknown start reason falls back to foreground importance check`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    whenever(mockStartInfo.reason).thenReturn(ApplicationStartInfo.START_REASON_OTHER)
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    SentryShadowActivityManager.setImportance(RunningAppProcessInfo.IMPORTANCE_FOREGROUND)
+    val metrics = AppStartMetrics.getInstance()
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    assertTrue(metrics.isAppLaunchedInForeground)
+  }
+
+  @Test
+  fun `background-spawned start is re-classified as warm on the first activity`() {
+    val mockStartInfo = mock<ApplicationStartInfo>()
+    whenever(mockStartInfo.startupState).thenReturn(ApplicationStartInfo.STARTUP_STATE_STARTED)
+    whenever(mockStartInfo.startType).thenReturn(ApplicationStartInfo.START_TYPE_COLD)
+    whenever(mockStartInfo.reason).thenReturn(ApplicationStartInfo.START_REASON_PUSH)
+    SentryShadowActivityManager.setHistoricalProcessStartReasons(listOf(mockStartInfo))
+    val metrics = AppStartMetrics.getInstance()
+    // App start span anchored at background process creation.
+    metrics.appStartTimeSpan.setStartedAt(42)
+
+    val app = ApplicationProvider.getApplicationContext<Application>()
+    metrics.registerLifecycleCallbacks(app)
+
+    assertFalse(metrics.isAppLaunchedInForeground)
+    assertEquals(AppStartMetrics.AppStartType.COLD, metrics.appStartType)
+
+    // User opens the app 20s later (under the 1-minute warm threshold).
+    val activityCreatedUptimeMs = 20_000L
+    SystemClock.setCurrentTimeMillis(activityCreatedUptimeMs)
+    metrics.onActivityCreated(mock<Activity>(), null)
+
+    // Re-classified as a warm start re-anchored at activity creation.
+    assertEquals(AppStartMetrics.AppStartType.WARM, metrics.appStartType)
+    assertTrue(metrics.isAppLaunchedInForeground)
+    assertEquals(activityCreatedUptimeMs, metrics.appStartTimeSpan.startUptimeMs)
+  }
+
   private fun waitForMainLooperIdle() {
     Handler(Looper.getMainLooper()).post {}
     Shadows.shadowOf(Looper.getMainLooper()).idle()

From ba5f1d58e7c52ac7d3ac72b3d2cb99b0de77f326 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 30 Jul 2026 16:47:37 +0200
Subject: [PATCH 351/391] fix(core): Report no-op executor tasks as cancelled
 (#5874)

* fix(core): Report no-op executor tasks as cancelled (JAVA-628)

NoOpSentryExecutorService returned a FutureTask that is never run and
never cancelled, so a caller had no way to tell a dropped task from a
queued one: isCancelled() and isDone() both stay false forever, and get()
blocks until it times out.

Return an already-cancelled Future instead, matching what
SentryExecutorService already does when its work queue is full, and state
the requirement on ISentryExecutorService so future implementations honour
it. CancelledFuture moves out of SentryExecutorService so both services
share one implementation.

An ActivityLifecycleIntegration test asserted a freshly scheduled ttfd
timeout was not cancelled while running on the no-op executor, so it was
really pinning the old pending-forever behaviour rather than the
scheduling it names. It now uses DeferredExecutorService, which queues.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* changelog

* Update sentry/src/main/java/io/sentry/ISentryExecutorService.java

Co-authored-by: arb <adam.brown@sentry.io>

* Apply suggestions from code review

Co-authored-by: arb <adam.brown@sentry.io>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
Co-authored-by: arb <adam.brown@sentry.io>
---
 CHANGELOG.md                                  |  2 +
 .../core/ActivityLifecycleIntegrationTest.kt  |  2 +
 .../src/main/kotlin/io/sentry/test/Mocks.kt   | 11 ++++--
 .../main/java/io/sentry/CancelledFuture.java  | 38 +++++++++++++++++++
 .../io/sentry/ISentryExecutorService.java     | 21 ++++++++--
 .../io/sentry/NoOpSentryExecutorService.java  |  7 ++--
 .../java/io/sentry/SentryExecutorService.java | 28 --------------
 .../sentry/NoOpSentryExecutorServiceTest.kt   | 15 ++++++++
 8 files changed, 85 insertions(+), 39 deletions(-)
 create mode 100644 sentry/src/main/java/io/sentry/CancelledFuture.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d826db437c5..045085bc494 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,8 @@
 - Prevent inflated cold app start when the OS spawns the process in the background (e.g. FCM push) on API 35+ ([#5841](https://github.com/getsentry/sentry-java/pull/5841))
 - Avoid a CPU busy-loop when recording discarded log or metric envelopes under rate limiting ([#5835](https://github.com/getsentry/sentry-java/pull/5835))
   - `ClientReportRecorder` now reads the item count from the envelope item header instead of deserializing the payload, which under sustained rate limiting could pin CPU cores while repeatedly throwing exceptions
+- Report tasks handed to a no-op `ISentryExecutorService` as cancelled ([#5874](https://github.com/getsentry/sentry-java/pull/5874))
+  - `NoOpSentryExecutorService` previously returned a `Future` that was never run and never cancelled, so callers could not tell a dropped task from a queued one and `get()` would block until its timeout
 
 ### Performance
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
index 166129f601b..c79d418efe5 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ActivityLifecycleIntegrationTest.kt
@@ -1975,6 +1975,8 @@ class ActivityLifecycleIntegrationTest {
     val sut = fixture.getSut()
     fixture.options.tracesSampleRate = 1.0
     fixture.options.isEnableTimeToFullDisplayTracing = true
+    // the timeout has to be really scheduled for cancelling it to be observable
+    fixture.options.executorService = DeferredExecutorService()
     sut.register(fixture.scopes, fixture.options)
     val activity = mock<Activity>()
     val activity2 = mock<Activity>()
diff --git a/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt b/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt
index 79076e9dc8f..b66c0f29475 100644
--- a/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt
+++ b/sentry-test-support/src/main/kotlin/io/sentry/test/Mocks.kt
@@ -76,12 +76,15 @@ class DeferredExecutorService : ISentryExecutorService {
 }
 
 class NonOverridableNoOpSentryExecutorService : ISentryExecutorService {
-  override fun submit(runnable: Runnable): Future<*> = FutureTask<Void> { null }
+  // mirrors NoOpSentryExecutorService: a task that is never run is reported as cancelled, so
+  // callers can tell it apart from a queued one
+  private fun <T> cancelledFuture(): FutureTask<T> = FutureTask<T> { null }.apply { cancel(false) }
 
-  override fun <T> submit(callable: Callable<T>): Future<T> = FutureTask<T> { null }
+  override fun submit(runnable: Runnable): Future<*> = cancelledFuture<Void>()
 
-  override fun schedule(runnable: Runnable, delayMillis: Long): Future<*> =
-    FutureTask<Void> { null }
+  override fun <T> submit(callable: Callable<T>): Future<T> = cancelledFuture()
+
+  override fun schedule(runnable: Runnable, delayMillis: Long): Future<*> = cancelledFuture<Void>()
 
   override fun close(timeoutMillis: Long) {}
 
diff --git a/sentry/src/main/java/io/sentry/CancelledFuture.java b/sentry/src/main/java/io/sentry/CancelledFuture.java
new file mode 100644
index 00000000000..502651597cb
--- /dev/null
+++ b/sentry/src/main/java/io/sentry/CancelledFuture.java
@@ -0,0 +1,38 @@
+package io.sentry;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * The {@link Future} an {@link ISentryExecutorService} hands back for a task it will never run.
+ * Callers can tell such a task apart from an accepted one through {@link #isCancelled()}, and are
+ * spared blocking in {@link #get()} on a result that is never coming.
+ */
+final class CancelledFuture<T> implements Future<T> {
+  @Override
+  public boolean cancel(final boolean mayInterruptIfRunning) {
+    return true;
+  }
+
+  @Override
+  public boolean isCancelled() {
+    return true;
+  }
+
+  @Override
+  public boolean isDone() {
+    return true;
+  }
+
+  @Override
+  public T get() {
+    throw new CancellationException();
+  }
+
+  @Override
+  public T get(final long timeout, final @NotNull TimeUnit unit) {
+    throw new CancellationException();
+  }
+}
diff --git a/sentry/src/main/java/io/sentry/ISentryExecutorService.java b/sentry/src/main/java/io/sentry/ISentryExecutorService.java
index 9bdef8db2b7..656308dae4a 100644
--- a/sentry/src/main/java/io/sentry/ISentryExecutorService.java
+++ b/sentry/src/main/java/io/sentry/ISentryExecutorService.java
@@ -6,7 +6,15 @@
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
-/** Sentry Executor Service that sends cached events and envelopes on App. start. */
+/**
+ * Sentry Executor Service that sends cached events and envelopes on App start.
+ *
+ * <p>Implementations that drop a task instead of running it — a no-op service, a full work queue —
+ * must report that through the returned {@link Future}: either throw {@link
+ * RejectedExecutionException} or return a {@link CancelledFuture}. Callers rely on this to tell a
+ * queued task from a dropped one, so a Future that will never complete and never reports
+ * cancellation leaves them waiting on a task that is never coming.
+ */
 @ApiStatus.Internal
 public interface ISentryExecutorService {
 
@@ -14,7 +22,7 @@ public interface ISentryExecutorService {
    * Submits a Runnable to the ThreadExecutor
    *
    * @param runnable the Runnable
-   * @return a Future of the Runnable
+   * @return a Future of the Runnable, already cancelled if the task will not be run
    */
   @NotNull
   Future<?> submit(final @NotNull Runnable runnable) throws RejectedExecutionException;
@@ -23,11 +31,18 @@ public interface ISentryExecutorService {
    * Submits a Callable to the ThreadExecutor
    *
    * @param callable the Callable
-   * @return a Future of the Callable
+   * @return a Future of the Callable, already cancelled if the task will not be run
    */
   @NotNull
   <T> Future<T> submit(final @NotNull Callable<T> callable) throws RejectedExecutionException;
 
+  /**
+   * Schedules a Runnable on the ThreadExecutor
+   *
+   * @param runnable the Runnable
+   * @param delayMillis how long to wait before running it
+   * @return a Future of the Runnable, already cancelled if the task will not be run
+   */
   @NotNull
   Future<?> schedule(final @NotNull Runnable runnable, final long delayMillis)
       throws RejectedExecutionException;
diff --git a/sentry/src/main/java/io/sentry/NoOpSentryExecutorService.java b/sentry/src/main/java/io/sentry/NoOpSentryExecutorService.java
index 37778c3cc09..b0ed80a86a1 100644
--- a/sentry/src/main/java/io/sentry/NoOpSentryExecutorService.java
+++ b/sentry/src/main/java/io/sentry/NoOpSentryExecutorService.java
@@ -2,7 +2,6 @@
 
 import java.util.concurrent.Callable;
 import java.util.concurrent.Future;
-import java.util.concurrent.FutureTask;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
@@ -18,17 +17,17 @@ private NoOpSentryExecutorService() {}
 
   @Override
   public @NotNull Future<?> submit(final @NotNull Runnable runnable) {
-    return new FutureTask<>(() -> null);
+    return new CancelledFuture<>();
   }
 
   @Override
   public @NotNull <T> Future<T> submit(final @NotNull Callable<T> callable) {
-    return new FutureTask<>(() -> null);
+    return new CancelledFuture<>();
   }
 
   @Override
   public @NotNull Future<?> schedule(@NotNull Runnable runnable, long delayMillis) {
-    return new FutureTask<>(() -> null);
+    return new CancelledFuture<>();
   }
 
   @Override
diff --git a/sentry/src/main/java/io/sentry/SentryExecutorService.java b/sentry/src/main/java/io/sentry/SentryExecutorService.java
index a469dca5853..e20c0835637 100644
--- a/sentry/src/main/java/io/sentry/SentryExecutorService.java
+++ b/sentry/src/main/java/io/sentry/SentryExecutorService.java
@@ -2,7 +2,6 @@
 
 import io.sentry.util.AutoClosableReentrantLock;
 import java.util.concurrent.Callable;
-import java.util.concurrent.CancellationException;
 import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
@@ -155,31 +154,4 @@ private static final class SentryExecutorServiceThread extends Thread {
       super(r, name);
     }
   }
-
-  private static final class CancelledFuture<T> implements Future<T> {
-    @Override
-    public boolean cancel(final boolean mayInterruptIfRunning) {
-      return true;
-    }
-
-    @Override
-    public boolean isCancelled() {
-      return true;
-    }
-
-    @Override
-    public boolean isDone() {
-      return true;
-    }
-
-    @Override
-    public T get() {
-      throw new CancellationException();
-    }
-
-    @Override
-    public T get(final long timeout, final @NotNull TimeUnit unit) {
-      throw new CancellationException();
-    }
-  }
 }
diff --git a/sentry/src/test/java/io/sentry/NoOpSentryExecutorServiceTest.kt b/sentry/src/test/java/io/sentry/NoOpSentryExecutorServiceTest.kt
index f9df0c52dda..212c1dcde56 100644
--- a/sentry/src/test/java/io/sentry/NoOpSentryExecutorServiceTest.kt
+++ b/sentry/src/test/java/io/sentry/NoOpSentryExecutorServiceTest.kt
@@ -1,7 +1,10 @@
 package io.sentry
 
+import com.google.common.truth.Truth.assertThat
 import java.util.concurrent.Callable
+import java.util.concurrent.CancellationException
 import kotlin.test.Test
+import kotlin.test.assertFailsWith
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import org.mockito.kotlin.mock
@@ -27,6 +30,18 @@ class NoOpSentryExecutorServiceTest {
     assertNotNull(future)
   }
 
+  @Test
+  fun `submitted tasks are reported as cancelled instead of pending forever`() {
+    assertThat(sut.submit(mock<Runnable>()).isCancelled).isTrue()
+    assertThat(sut.submit(mock<Callable<*>>()).isCancelled).isTrue()
+    assertThat(sut.schedule(mock(), 0).isCancelled).isTrue()
+  }
+
+  @Test
+  fun `getting the result of a dropped task fails fast`() {
+    assertFailsWith<CancellationException> { sut.submit(mock<Runnable>()).get() }
+  }
+
   @Test fun `close does not throw`() = sut.close(0)
 
   @Test

From 1e904b2bbce8d8aac46b426eb0f9888e53384eac Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 30 Jul 2026 16:53:07 +0200
Subject: [PATCH 352/391] perf(core): Use build-time class availability (#5875)

* perf(core): Use build-time class availability

Consult class availability data injected by build tooling before falling back to reflection. Keep the map nullable so consumers without supporting tooling preserve current behavior.

Refs JAVA-654
Co-Authored-By: Codex <noreply@openai.com>

* ref(core): Make class availability package-private

Allow package-local tests to set class availability without reflection.

Refs LINEAR-JAVA-654

Co-Authored-By: Codex <noreply@openai.com>

---------

Co-authored-by: Codex <noreply@openai.com>
---
 .../main/java/io/sentry/util/LoadClass.java   | 14 ++++++++++
 .../test/java/io/sentry/util/LoadClassTest.kt | 27 +++++++++++++++++++
 2 files changed, 41 insertions(+)

diff --git a/sentry/src/main/java/io/sentry/util/LoadClass.java b/sentry/src/main/java/io/sentry/util/LoadClass.java
index 2c39cace39b..bf179fad459 100644
--- a/sentry/src/main/java/io/sentry/util/LoadClass.java
+++ b/sentry/src/main/java/io/sentry/util/LoadClass.java
@@ -4,6 +4,7 @@
 import io.sentry.ILogger;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
+import java.util.Map;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -11,6 +12,9 @@
 @Open
 public class LoadClass {
 
+  // Populated by the Sentry Android Gradle plugin for class names it can resolve at build time.
+  static @Nullable Map<String, Boolean> classAvailability;
+
   /**
    * Loads and initializes a class via reflection. Use this when you intend to actually use the
    * class (e.g. instantiate it or invoke its methods). The returned class is fully initialized, so
@@ -57,6 +61,16 @@ public class LoadClass {
    * @return true if the class is on the classpath
    */
   public boolean isClassAvailable(final @NotNull String clazz, final @Nullable ILogger logger) {
+    final @Nullable Map<String, Boolean> availability = classAvailability;
+    if (availability != null) {
+      final @Nullable Boolean available = availability.get(clazz);
+      if (available != null) {
+        if (!available && logger != null) {
+          logger.log(SentryLevel.INFO, "Class not available: " + clazz);
+        }
+        return available;
+      }
+    }
     return loadClass(clazz, logger, false) != null;
   }
 
diff --git a/sentry/src/test/java/io/sentry/util/LoadClassTest.kt b/sentry/src/test/java/io/sentry/util/LoadClassTest.kt
index 7a8bc802049..4cb921feff8 100644
--- a/sentry/src/test/java/io/sentry/util/LoadClassTest.kt
+++ b/sentry/src/test/java/io/sentry/util/LoadClassTest.kt
@@ -1,5 +1,6 @@
 package io.sentry.util
 
+import com.google.common.truth.Truth.assertThat
 import kotlin.test.Test
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
@@ -7,6 +8,32 @@ import kotlin.test.assertNull
 import kotlin.test.assertTrue
 
 class LoadClassTest {
+  @Test
+  fun `isClassAvailable uses known build-time results and reflects unknown classes`() {
+    LoadClass.classAvailability =
+      mapOf(
+        "io.sentry.SentryEvent" to false,
+        "io.sentry.ThisClassDoesNotExist" to true,
+      )
+
+    try {
+      val loadClass = LoadClass()
+      assertThat(loadClass.isClassAvailable("io.sentry.SentryEvent", null as io.sentry.ILogger?))
+        .isFalse()
+      assertThat(
+          loadClass.isClassAvailable(
+            "io.sentry.ThisClassDoesNotExist",
+            null as io.sentry.ILogger?,
+          )
+        )
+        .isTrue()
+      assertThat(loadClass.isClassAvailable("io.sentry.Sentry", null as io.sentry.ILogger?))
+        .isTrue()
+    } finally {
+      LoadClass.classAvailability = null
+    }
+  }
+
   @Test
   fun `loadClass returns the class when it is available`() {
     assertNotNull(LoadClass().loadClass("io.sentry.SentryEvent", null))

From 5cb2c360fb86e315ee6c775aa7f93e871cf0f2d5 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Thu, 30 Jul 2026 16:59:12 +0200
Subject: [PATCH 353/391] perf(replay): Use RGB_565 when alpha is unnecessary
 (#5821)

* fix(replay): Prevent concurrent PixelCopy frame access

Keep PixelCopy, masking, compositing, and cleanup from accessing the shared bitmap concurrently.

Fixes GH-5340

Co-Authored-By: Codex <noreply@openai.com>

* fix(android-replay): Preserve pending PixelCopy capture

Re-arm the recorder's content-change gate when a capture is skipped because another frame is still in flight. This ensures the latest UI state is retried on the next capture interval.

Refs GH-5340
Co-Authored-By: OpenAI Codex <noreply@openai.com>

* perf(android-replay): Use RGB_565 when alpha is unnecessary

Reduce replay screenshot memory while retaining ARGB_8888 for SurfaceView compositing.

Refs GH-5340
Co-Authored-By: Codex <noreply@openai.com>

* perf(screenshot): Use RGB_565 for screenshot capture bitmaps

Screen content is always opaque so the alpha channel in ARGB_8888 is wasted.
RGB_565 halves the per-screenshot bitmap memory (~2B/px vs 4B/px).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Remove duplicate test methods from rebase

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* changelog

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: Move changelog entry to Unreleased section

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(screenshot): Log PixelCopy result code on failure

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Format code

---------

Co-authored-by: Codex <noreply@openai.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Sentry Github Bot <bot+github-bot@sentry.io>
---
 CHANGELOG.md                                    |  1 +
 .../android/core/ScreenshotEventProcessor.java  |  2 +-
 .../core/internal/util/ScreenshotUtils.java     | 17 ++++++++++-------
 .../android/replay/screenshot/CanvasStrategy.kt |  2 +-
 .../replay/screenshot/PixelCopyStrategy.kt      | 10 +++++++++-
 .../replay/screenshot/PixelCopyStrategyTest.kt  |  9 +++++++--
 6 files changed, 29 insertions(+), 12 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 045085bc494..de78e3c3d54 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@
 
 ### Performance
 
+- Use `RGB_565` instead of `ARGB_8888` for screenshot and replay capture bitmaps, halving per-frame memory usage ([#5821](https://github.com/getsentry/sentry-java/pull/5821))
 - Remove an unused lock from `SentryPerformanceProvider`, which was allocated on every cold start in `ContentProvider.onCreate` without ever being acquired ([#5871](https://github.com/getsentry/sentry-java/pull/5871))
 - Parse the app start profiling config with only the deserializer it needs instead of building a full `JsonSerializer` and `SentryOptions`, cutting 188 of 221 allocations on the main thread before `Application.onCreate` ([#5867](https://github.com/getsentry/sentry-java/pull/5867))
 - Batch and coalesce scope-persistence disk writes to reduce startup cost ([#5791](https://github.com/getsentry/sentry-java/pull/5791))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java b/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java
index bbef7846cd9..dd0e259f937 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/ScreenshotEventProcessor.java
@@ -216,7 +216,7 @@ private boolean isMaskingEnabled() {
     try (final MaskRenderer maskRenderer = new MaskRenderer()) {
       // Make bitmap mutable if needed
       if (!screenshot.isMutable()) {
-        mutableBitmap = screenshot.copy(Bitmap.Config.ARGB_8888, true);
+        mutableBitmap = screenshot.copy(Bitmap.Config.RGB_565, true);
         if (mutableBitmap == null) {
           screenshot.recycle();
           return null;
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/ScreenshotUtils.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/ScreenshotUtils.java
index db2b12122a5..092caa040db 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/ScreenshotUtils.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/ScreenshotUtils.java
@@ -18,7 +18,7 @@
 import java.io.ByteArrayOutputStream;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
@@ -97,9 +97,8 @@ public class ScreenshotUtils {
     }
 
     try {
-      // ARGB_8888 -> This configuration is very flexible and offers the best quality
       final Bitmap bitmap =
-          Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.ARGB_8888);
+          Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.RGB_565);
 
       final @NotNull CountDownLatch latch = new CountDownLatch(1);
 
@@ -110,21 +109,21 @@ public class ScreenshotUtils {
         thread.start();
 
         boolean success = false;
+        final AtomicInteger copyResultCode = new AtomicInteger(-1);
         try {
           final Handler handler = new Handler(thread.getLooper());
-          final AtomicBoolean copyResultSuccess = new AtomicBoolean(false);
 
           PixelCopy.request(
               window,
               bitmap,
               copyResult -> {
-                copyResultSuccess.set(copyResult == PixelCopy.SUCCESS);
+                copyResultCode.set(copyResult);
                 latch.countDown();
               },
               handler);
 
-          success =
-              latch.await(CAPTURE_TIMEOUT_MS, TimeUnit.MILLISECONDS) && copyResultSuccess.get();
+          final boolean completed = latch.await(CAPTURE_TIMEOUT_MS, TimeUnit.MILLISECONDS);
+          success = completed && copyResultCode.get() == PixelCopy.SUCCESS;
         } catch (Throwable e) {
           // ignored
           logger.log(SentryLevel.ERROR, "Taking screenshot using PixelCopy failed.", e);
@@ -133,6 +132,10 @@ public class ScreenshotUtils {
         }
 
         if (!success) {
+          logger.log(
+              SentryLevel.WARNING,
+              "PixelCopy failed for screenshot capture (result=%d).",
+              copyResultCode.get());
           return null;
         }
       } else {
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/CanvasStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/CanvasStrategy.kt
index 406b23a9e4e..c3deefbf71b 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/CanvasStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/CanvasStrategy.kt
@@ -97,7 +97,7 @@ internal class CanvasStrategy(
               Bitmap.createBitmap(
                 config.recordingWidth,
                 config.recordingHeight,
-                Bitmap.Config.ARGB_8888,
+                Bitmap.Config.RGB_565,
               )
           }
         }
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
index 14871b45d6d..06be58e19de 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/screenshot/PixelCopyStrategy.kt
@@ -51,7 +51,15 @@ internal class PixelCopyStrategy(
   private val executor = executorProvider.getExecutor()
   private val mainLooperHandler = executorProvider.getMainLooperHandler()
   private val screenshot =
-    Bitmap.createBitmap(config.recordingWidth, config.recordingHeight, Bitmap.Config.ARGB_8888)
+    Bitmap.createBitmap(
+      config.recordingWidth,
+      config.recordingHeight,
+      if (options.sessionReplay.isCaptureSurfaceViews) {
+        Bitmap.Config.ARGB_8888
+      } else {
+        Bitmap.Config.RGB_565
+      },
+    )
   private val prescaledMatrix by
     lazy(NONE) { Matrix().apply { preScale(config.scaleFactorX, config.scaleFactorY) } }
   private val lastCaptureSuccessful = AtomicBoolean(false)
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
index 0098ab24fc6..587927e9793 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/screenshot/PixelCopyStrategyTest.kt
@@ -40,6 +40,7 @@ import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
@@ -470,7 +471,9 @@ class PixelCopyStrategyTest {
 
     assertFalse(fixture.contentChangedMarked.get())
     assertTrue(strategy.lastCaptureSuccessful())
-    verify(fixture.callback).onScreenshotRecorded(any<Bitmap>())
+    val screenshot = argumentCaptor<Bitmap>()
+    verify(fixture.callback).onScreenshotRecorded(screenshot.capture())
+    assertEquals(Bitmap.Config.RGB_565, screenshot.firstValue.config)
   }
 
   @Test
@@ -502,7 +505,9 @@ class PixelCopyStrategyTest {
     shadowOf(Looper.getMainLooper()).idle()
 
     assertTrue(strategy.lastCaptureSuccessful())
-    verify(fixture.callback).onScreenshotRecorded(any<Bitmap>())
+    val screenshot = argumentCaptor<Bitmap>()
+    verify(fixture.callback).onScreenshotRecorded(screenshot.capture())
+    assertEquals(Bitmap.Config.ARGB_8888, screenshot.firstValue.config)
   }
 
   @Test

From 934244e8861ceadf8a7e2a9450cad64d733698e7 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Thu, 30 Jul 2026 17:11:38 +0200
Subject: [PATCH 354/391] fix(android): Prevent Relay from rejecting
 single-sample ANR profiles  (#5872)

Relay currently rejects ANR profiles with a single sample, even though they're still useful to customers. (Relay's policy was developed with continuous profiles in mind, before ANR profiles were a thing.) Commit updates our StackTraceConverter to add a second, synthetic sample whenever an ANR profile would otherwise only contain one.

The synthetic sample duplicates the original, save for a minor offset to its timestamp (to avoid misleading the user about the ANRs cause or duration).
---
 CHANGELOG.md                                  |  1 +
 .../android/core/anr/StackTraceConverter.java | 31 +++++++++++
 .../ApplicationExitInfoEventProcessorTest.kt  |  6 +++
 .../core/anr/AnrStackTraceConverterTest.kt    | 54 ++++++++++++++++++-
 sentry/api/sentry.api                         |  1 +
 .../protocol/profiling/SentrySample.java      | 10 ++++
 .../protocol/profiling/SentrySampleTest.kt    | 30 +++++++++++
 7 files changed, 132 insertions(+), 1 deletion(-)
 create mode 100644 sentry/src/test/java/io/sentry/protocol/profiling/SentrySampleTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index de78e3c3d54..e4aae13364f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Preserve single-sample ANR profile chunks so profiles remain available on ANR events ([#5872](https://github.com/getsentry/sentry-java/pull/5872))
 - Prevent inflated cold app start when the OS spawns the process in the background (e.g. FCM push) on API 35+ ([#5841](https://github.com/getsentry/sentry-java/pull/5841))
 - Avoid a CPU busy-loop when recording discarded log or metric envelopes under rate limiting ([#5835](https://github.com/getsentry/sentry-java/pull/5835))
   - `ClientReportRecorder` now reads the item count from the envelope item header instead of deserializing the payload, which under sustained rate limiting could pin CPU cores while repeatedly throwing exceptions
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/anr/StackTraceConverter.java b/sentry-android-core/src/main/java/io/sentry/android/core/anr/StackTraceConverter.java
index f6f29689f72..8f1254e08ca 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/anr/StackTraceConverter.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/anr/StackTraceConverter.java
@@ -33,6 +33,14 @@ public final class StackTraceConverter {
   private static final String MAIN_THREAD_ID = "0";
   private static final String MAIN_THREAD_NAME = "main";
 
+  /**
+   * Timestamp offset used with synthetic ANR profile samples. (Currently 33 ms.)
+   *
+   * <p>Places the synthetic sample halfway to the next ANR polling tick.
+   */
+  private static final double SYNTHETIC_SAMPLE_OFFSET_SECONDS =
+      (AnrProfilingIntegration.POLLING_INTERVAL_MS / 2.0d) / 1000.0d;
+
   /**
    * Converts a list of {@link AnrStackTrace} objects to a {@link SentryProfile}.
    *
@@ -80,6 +88,15 @@ public static SentryProfile convert(final @NotNull AnrProfile anrProfile) {
       profile.getSamples().add(sample);
     }
 
+    // Relay will reject ANR profiles with only one sample, even though they're still useful.
+    // (Relay's policy was defined with continuous profiles in mind, before ANR profiles were a
+    // thing.) If we only have one sample, synthesize another that only differs in its timestamp.
+    if (profile.getSamples().size() == 1) {
+      final @NotNull SentrySample originalSample = profile.getSamples().get(0);
+      final @NotNull SentrySample syntheticSample = createSyntheticSample(originalSample);
+      profile.getSamples().add(syntheticSample);
+    }
+
     profile.setFrames(frames);
     profile.setStacks(stacks);
 
@@ -147,4 +164,18 @@ private static SentryStackFrame createSentryStackFrame(@NotNull StackTraceElemen
     }
     return frame;
   }
+
+  /**
+   * Creates a {@link SentrySample} identical to {@code originalSample}, save that its timestamp is
+   * advanced by {@link #SYNTHETIC_SAMPLE_OFFSET_SECONDS}.
+   *
+   * <p>Lets us produce a plausible synthetic sample without misleading the user about the ANR's
+   * actual duration or cause.
+   */
+  @NotNull
+  private static SentrySample createSyntheticSample(@NotNull SentrySample originalSample) {
+    final @NotNull SentrySample syntheticSample = new SentrySample(originalSample);
+    syntheticSample.setTimestamp(originalSample.getTimestamp() + SYNTHETIC_SAMPLE_OFFSET_SECONDS);
+    return syntheticSample;
+  }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
index e80c738b5ea..176ca460eb1 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ApplicationExitInfoEventProcessorTest.kt
@@ -1012,9 +1012,15 @@ class ApplicationExitInfoEventProcessorTest {
       mockedSentry.`when`<Any> { Sentry.getCurrentScopes() }.thenReturn(scopes)
 
       val processed = processor.process(SentryEvent(), hint)
+      val chunkCaptor = argumentCaptor<ProfileChunk>()
+      verify(scopes).captureProfileChunk(chunkCaptor.capture())
+      val sentryProfile = chunkCaptor.firstValue.sentryProfile
 
       assertNotNull(processed?.contexts?.profile)
       assertNotNull(processed.contexts.profile?.profilerId)
+      assertNotNull(sentryProfile)
+      // Two samples are present b/c the converter adds a synthetic one to keep Relay happy.
+      assertEquals(2, sentryProfile.samples.size)
     }
   }
 
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceConverterTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceConverterTest.kt
index f48f1674166..9dcde8eb4a6 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceConverterTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/anr/AnrStackTraceConverterTest.kt
@@ -19,7 +19,8 @@ class AnrStackTraceConverterTest {
     val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
 
     Assert.assertNotNull(profile)
-    Assert.assertEquals(1, profile.samples.size)
+    // Two samples are present b/c the converter adds a synthetic one to keep Relay happy.
+    Assert.assertEquals(2, profile.samples.size)
     Assert.assertEquals(2, profile.frames.size)
     Assert.assertEquals(1, profile.stacks.size)
 
@@ -46,6 +47,57 @@ class AnrStackTraceConverterTest {
     Assert.assertEquals(1.0, sample.timestamp, 0.001) // 1000ms = 1s
   }
 
+  @Test
+  fun testAddSyntheticSampleIfOnlyOneSamplePresent() {
+    val elements = arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+    anrStackTraces.add(AnrStackTrace(1000, elements))
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    val originalSample = profile.samples[0]
+    val syntheticSample = profile.samples[1]
+    val expectedOffsetSeconds = AnrProfilingIntegration.POLLING_INTERVAL_MS / 2.0 / 1000.0
+
+    Assert.assertEquals(
+      originalSample.timestamp + expectedOffsetSeconds,
+      syntheticSample.timestamp,
+      0.001,
+    )
+
+    Assert.assertTrue(profile.stacks[syntheticSample.stackId].isNotEmpty())
+    Assert.assertEquals(2, profile.samples.size)
+    Assert.assertEquals(1, profile.stacks.size)
+    Assert.assertEquals(1, profile.frames.size)
+  }
+
+  @Test
+  fun testDoNotAddSyntheticSampleIfMultipleSamplesPresent() {
+    val elements = arrayOf(StackTraceElement("com.example.MyClass", "method1", "MyClass.java", 42))
+
+    val anrStackTraces: MutableList<AnrStackTrace?> = ArrayList()
+    anrStackTraces.add(AnrStackTrace(1000, elements))
+    anrStackTraces.add(AnrStackTrace(2000, elements))
+
+    val profile = StackTraceConverter.convert(AnrProfile(anrStackTraces))
+
+    Assert.assertEquals(2, profile.samples.size)
+    Assert.assertEquals(1.0, profile.samples[0].timestamp, 0.001)
+    Assert.assertEquals(2.0, profile.samples[1].timestamp, 0.001)
+    Assert.assertEquals(1, profile.stacks.size)
+    Assert.assertEquals(1, profile.frames.size)
+  }
+
+  @Test
+  fun testDoNotAddSyntheticSampleIfNoSamplesPresent() {
+    val profile = StackTraceConverter.convert(AnrProfile(ArrayList()))
+
+    Assert.assertEquals(0, profile.samples.size)
+    Assert.assertEquals(0, profile.stacks.size)
+    Assert.assertEquals(0, profile.frames.size)
+  }
+
   @Test
   fun testFrameDeduplication() {
     // Create two stack traces with duplicate frames
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index b807f70a88d..51cffae3302 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -7066,6 +7066,7 @@ public final class io/sentry/protocol/profiling/SentryProfile$JsonKeys {
 
 public final class io/sentry/protocol/profiling/SentrySample : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
 	public fun <init> ()V
+	public fun <init> (Lio/sentry/protocol/profiling/SentrySample;)V
 	public fun getStackId ()I
 	public fun getThreadId ()Ljava/lang/String;
 	public fun getTimestamp ()D
diff --git a/sentry/src/main/java/io/sentry/protocol/profiling/SentrySample.java b/sentry/src/main/java/io/sentry/protocol/profiling/SentrySample.java
index af9053742d3..a21b3a4af9d 100644
--- a/sentry/src/main/java/io/sentry/protocol/profiling/SentrySample.java
+++ b/sentry/src/main/java/io/sentry/protocol/profiling/SentrySample.java
@@ -8,6 +8,7 @@
 import io.sentry.JsonUnknown;
 import io.sentry.ObjectReader;
 import io.sentry.ObjectWriter;
+import io.sentry.util.CollectionUtils;
 import io.sentry.vendor.gson.stream.JsonToken;
 import java.io.IOException;
 import java.util.HashMap;
@@ -27,6 +28,15 @@ public final class SentrySample implements JsonUnknown, JsonSerializable {
 
   private @Nullable Map<String, Object> unknown;
 
+  public SentrySample() {}
+
+  public SentrySample(final @NotNull SentrySample sample) {
+    this.timestamp = sample.timestamp;
+    this.stackId = sample.stackId;
+    this.threadId = sample.threadId;
+    this.unknown = CollectionUtils.newConcurrentHashMap(sample.unknown);
+  }
+
   public double getTimestamp() {
     return timestamp;
   }
diff --git a/sentry/src/test/java/io/sentry/protocol/profiling/SentrySampleTest.kt b/sentry/src/test/java/io/sentry/protocol/profiling/SentrySampleTest.kt
new file mode 100644
index 00000000000..49c587b3004
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/protocol/profiling/SentrySampleTest.kt
@@ -0,0 +1,30 @@
+package io.sentry.protocol.profiling
+
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+
+class SentrySampleTest {
+
+  @Test
+  fun `copying sample keeps values and copies unknown`() {
+    val unknown = mutableMapOf<String, Any>("key" to "value")
+    val original =
+      SentrySample().apply {
+        timestamp = 1.23
+        stackId = 4
+        threadId = "main"
+        setUnknown(unknown)
+      }
+
+    val copy = SentrySample(original)
+
+    assertThat(copy.timestamp).isEqualTo(original.timestamp)
+    assertThat(copy.stackId).isEqualTo(original.stackId)
+    assertThat(copy.threadId).isEqualTo(original.threadId)
+    assertThat(copy.unknown).containsExactlyEntriesIn(original.unknown)
+    assertThat(copy.unknown).isNotSameInstanceAs(original.unknown)
+
+    unknown["key"] = "changed"
+    assertThat(copy.unknown).containsEntry("key", "value")
+  }
+}

From 462dea262875e064828683e8ef88d95c78e5e2f2 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Fri, 31 Jul 2026 10:51:41 +0200
Subject: [PATCH 355/391] fix(app-start): Fix detection of foreground app start
 (#5880)

* fix(app-start): Fix detection of foreground app start

* Update sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java

Co-authored-by: arb <adam.brown@sentry.io>

* Update Changelog

---------

Co-authored-by: arb <adam.brown@sentry.io>
---
 CHANGELOG.md                                  |  2 +-
 .../core/performance/AppStartMetrics.java     | 37 ++++++--------
 .../core/performance/AppStartMetricsTest.kt   | 51 ++++++++++++++-----
 3 files changed, 54 insertions(+), 36 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e4aae13364f..a79d7527bd0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,8 +4,8 @@
 
 ### Fixes
 
+- Prevent inflated cold app start when the OS spawns the process in the background (e.g. FCM push) on API 35+ ([#5841](https://github.com/getsentry/sentry-java/pull/5841), [#5880](https://github.com/getsentry/sentry-java/pull/5880))
 - Preserve single-sample ANR profile chunks so profiles remain available on ANR events ([#5872](https://github.com/getsentry/sentry-java/pull/5872))
-- Prevent inflated cold app start when the OS spawns the process in the background (e.g. FCM push) on API 35+ ([#5841](https://github.com/getsentry/sentry-java/pull/5841))
 - Avoid a CPU busy-loop when recording discarded log or metric envelopes under rate limiting ([#5835](https://github.com/getsentry/sentry-java/pull/5835))
   - `ClientReportRecorder` now reads the item count from the envelope item header instead of deserializing the payload, which under sustained rate limiting could pin CPU cores while repeatedly throwing exceptions
 - Report tasks handed to a no-op `ISentryExecutorService` as cancelled ([#5874](https://github.com/getsentry/sentry-java/pull/5874))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
index 97f5c5fd6ec..eb1a10dd646 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/performance/AppStartMetrics.java
@@ -30,7 +30,6 @@
 import io.sentry.android.core.internal.util.FirstDrawDoneListener;
 import io.sentry.protocol.SentryId;
 import io.sentry.util.AutoClosableReentrantLock;
-import io.sentry.util.LazyEvaluator;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -70,14 +69,7 @@ public enum AppStartType {
       new AutoClosableReentrantLock();
 
   private @NotNull AppStartType appStartType = AppStartType.UNKNOWN;
-  private final LazyEvaluator<Boolean> appLaunchedInForeground =
-      new LazyEvaluator<>(
-          new LazyEvaluator.Evaluator<Boolean>() {
-            @Override
-            public @NotNull Boolean evaluate() {
-              return ContextUtils.isForegroundImportance();
-            }
-          });
+  private @Nullable volatile Boolean appLaunchedInForeground;
   private volatile long firstIdle = -1;
 
   private final @NotNull TimeSpan appStartSpan;
@@ -239,12 +231,12 @@ public void setAppStartType(final @NotNull AppStartType appStartType) {
   }
 
   public boolean isAppLaunchedInForeground() {
-    return appLaunchedInForeground.getValue();
+    return Boolean.TRUE.equals(appLaunchedInForeground);
   }
 
   @VisibleForTesting
   public void setAppLaunchedInForeground(final boolean appLaunchedInForeground) {
-    this.appLaunchedInForeground.setValue(appLaunchedInForeground);
+    this.appLaunchedInForeground = appLaunchedInForeground;
   }
 
   public void setHeadlessAppStartListener(final @Nullable HeadlessAppStartListener listener) {
@@ -318,8 +310,7 @@ public void onAppStartSpansSent() {
   }
 
   public boolean shouldSendStartMeasurements(final boolean ignoreForegroundCheck) {
-    return shouldSendStartMeasurements
-        && (ignoreForegroundCheck || appLaunchedInForeground.getValue());
+    return shouldSendStartMeasurements && (ignoreForegroundCheck || isAppLaunchedInForeground());
   }
 
   public boolean shouldSendStartMeasurements() {
@@ -349,7 +340,7 @@ public long getClassLoadedUptimeMs() {
       final @NotNull SentryAndroidOptions options) {
     // If the app start type was never determined or app wasn't launched in foreground,
     // the app start is considered invalid
-    if (appStartType != AppStartType.UNKNOWN && appLaunchedInForeground.getValue()) {
+    if (appStartType != AppStartType.UNKNOWN && isAppLaunchedInForeground()) {
       if (options.isEnablePerformanceV2()) {
         // Only started when sdk version is >= N
         final @NotNull TimeSpan appStartSpan = getAppStartTimeSpan();
@@ -412,7 +403,7 @@ public void clear() {
     }
     appStartContinuousProfiler = null;
     appStartSamplingDecision = null;
-    appLaunchedInForeground.resetValue();
+    appLaunchedInForeground = null;
     isCallbackRegistered = false;
     shouldSendStartMeasurements = true;
     firstDrawDone.set(false);
@@ -510,7 +501,7 @@ public void registerLifecycleCallbacks(final @NotNull Application application) {
       return;
     }
     isCallbackRegistered = true;
-    appLaunchedInForeground.resetValue();
+    appLaunchedInForeground = null;
     application.registerActivityLifecycleCallbacks(instance);
 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
@@ -529,7 +520,7 @@ public void registerLifecycleCallbacks(final @NotNull Application application) {
               } else {
                 appStartType = AppStartType.WARM;
               }
-              appLaunchedInForeground.setValue(isForegroundStartReason(info.getReason()));
+              appLaunchedInForeground = isForegroundStartReason(info.getReason());
             }
           }
         } catch (RuntimeException ignored) {
@@ -543,6 +534,10 @@ public void registerLifecycleCallbacks(final @NotNull Application application) {
         }
       }
     }
+    // Fallback, if no matching ApplicationStartInfo is available
+    if (appLaunchedInForeground == null) {
+      appLaunchedInForeground = ContextUtils.isForegroundImportance();
+    }
 
     if (appStartType == AppStartType.UNKNOWN || headlessAppStartListener != null) {
       scheduleHeadlessAppStartCheckOnMain();
@@ -591,7 +586,7 @@ private void handleHeadlessAppStartIfNeededOnMain() {
         return;
       }
 
-      appLaunchedInForeground.setValue(false);
+      appLaunchedInForeground = false;
 
       // Headless starts have no Activity signal for the pre-API 35 warm/cold heuristic.
       // If ApplicationStartInfo did not resolve the type, classify the process start as cold.
@@ -677,7 +672,7 @@ public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle saved
       // An active extension explicitly keeps the launch alive: resetting the span here would make
       // the extended vital measure from the activity while the eager app.start transaction stays
       // anchored at process start.
-      if ((!appLaunchedInForeground.getValue()
+      if ((!isAppLaunchedInForeground()
               || durationSinceAppStartMillis > TimeUnit.MINUTES.toMillis(1))
           && !appStartExtension.isActive()) {
         appStartType = AppStartType.WARM;
@@ -698,7 +693,7 @@ public void onActivityCreated(@NonNull Activity activity, @Nullable Bundle saved
         }
       }
     }
-    appLaunchedInForeground.setValue(true);
+    appLaunchedInForeground = true;
   }
 
   @Override
@@ -744,7 +739,7 @@ public void onActivityDestroyed(@NonNull Activity activity) {
     // as the next onActivityCreated will treat it as a new warm app start
     if (remainingActivities == 0 && !activity.isChangingConfigurations()) {
       appStartType = AppStartType.WARM;
-      appLaunchedInForeground.setValue(true);
+      appLaunchedInForeground = true;
       shouldSendStartMeasurements = true;
       firstDrawDone.set(false);
     }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
index edf72655740..6a32e7d453b 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/performance/AppStartMetricsTest.kt
@@ -241,15 +241,16 @@ class AppStartMetricsTest {
   }
 
   @Test
-  fun `headless app start fires HeadlessAppStartListener`() = headlessProcess {
-    val listenerCalls = AtomicInteger()
+  fun `headless app start fires HeadlessAppStartListener`() =
+    withProcessImportance(false) {
+      val listenerCalls = AtomicInteger()
 
-    AppStartMetrics.getInstance().setHeadlessAppStartListener { listenerCalls.incrementAndGet() }
-    AppStartMetrics.getInstance().registerLifecycleCallbacks(mock<Application>())
-    waitForMainLooperIdle()
+      AppStartMetrics.getInstance().setHeadlessAppStartListener { listenerCalls.incrementAndGet() }
+      AppStartMetrics.getInstance().registerLifecycleCallbacks(mock<Application>())
+      waitForMainLooperIdle()
 
-    assertEquals(1, listenerCalls.get())
-  }
+      assertEquals(1, listenerCalls.get())
+    }
 
   @Test
   fun `foreground process does not fire HeadlessAppStartListener`() {
@@ -295,7 +296,7 @@ class AppStartMetricsTest {
 
   @Test
   fun `resolveHeadlessAppStartEndTime uses applicationOnCreate stop when Gradle plugin instrumented`() =
-    headlessProcess {
+    withProcessImportance(false) {
       val metrics = AppStartMetrics.getInstance()
       metrics.appStartTimeSpan.setStartedAt(100)
       metrics.setHeadlessAppStartListener {}
@@ -312,7 +313,7 @@ class AppStartMetricsTest {
 
   @Test
   fun `resolveHeadlessAppStartEndTime falls back to CLASS_LOADED_UPTIME_MS when no plugin and no ApplicationStartInfo`() =
-    headlessProcess {
+    withProcessImportance(false) {
       val metrics = AppStartMetrics.getInstance()
       metrics.setClassLoadedUptimeMs(200)
       metrics.appStartTimeSpan.setStartedAt(100)
@@ -371,12 +372,18 @@ class AppStartMetricsTest {
     Shadows.shadowOf(Looper.getMainLooper()).idle()
   }
 
-  // Simulates a real headless start (broadcast/service), i.e. a non-foreground-importance process.
-  // The Robolectric default importance in this test class is IMPORTANCE_FOREGROUND, so headless
-  // scenarios must opt into a background importance explicitly.
-  private fun <T> headlessProcess(block: () -> T): T =
+  /**
+   * Mocks the process importance to simulate a user initiated start (e.g. launcher) or a real
+   * headless start (broadcast/service), i.e. a non-foreground-importance process.
+   *
+   * The Robolectric default importance in this test class is IMPORTANCE_FOREGROUND, so any headless
+   * scenarios must opt into a background importance explicitly.
+   */
+  private fun <T> withProcessImportance(isForeground: Boolean, block: () -> T): T =
     mockStatic(ContextUtils::class.java).use { contextUtils ->
-      contextUtils.`when`<Boolean> { ContextUtils.isForegroundImportance() }.thenReturn(false)
+      contextUtils
+        .`when`<Boolean> { ContextUtils.isForegroundImportance() }
+        .thenReturn(isForeground)
       block()
     }
 
@@ -1123,4 +1130,20 @@ class AppStartMetricsTest {
     assertEquals(now, metrics.appStartTimeSpan.startUptimeMs)
     metrics.appStartExtension.setExtendAppStartListener(null)
   }
+
+  @Test
+  fun `broadcast starts are not considered a foreground start`() =
+    withProcessImportance(false) {
+      val metrics = AppStartMetrics.getInstance()
+      metrics.registerLifecycleCallbacks(mock<Application>())
+      assertFalse(metrics.isAppLaunchedInForeground)
+    }
+
+  @Test
+  fun `typical app starts are considered a foreground start`() =
+    withProcessImportance(true) {
+      val metrics = AppStartMetrics.getInstance()
+      metrics.registerLifecycleCallbacks(mock<Application>())
+      assertTrue(metrics.isAppLaunchedInForeground)
+    }
 }

From e76ecde489686e8508f3c593ef656babf557b5bc Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 4 Aug 2026 08:30:21 +0000
Subject: [PATCH 356/391] chore(deps): bump the github-actions group with 5
 updates (#5882)

Bumps the github-actions group with 5 updates:

| Package | From | To |
| --- | --- | --- |
| [actions/setup-java](https://github.com/actions/setup-java) | `5.6.0` | `5.7.0` |
| [getsentry/craft/.github/workflows/changelog-preview.yml](https://github.com/getsentry/craft) | `2.27.2` | `2.28.0` |
| [github/codeql-action/init](https://github.com/github/codeql-action) | `4.37.3` | `4.37.4` |
| [github/codeql-action/analyze](https://github.com/github/codeql-action) | `4.37.3` | `4.37.4` |
| [getsentry/craft](https://github.com/getsentry/craft) | `2.27.2` | `2.28.0` |


Updates `actions/setup-java` from 5.6.0 to 5.7.0
- [Release notes](https://github.com/actions/setup-java/releases)
- [Commits](https://github.com/actions/setup-java/compare/03ad4de0992f5dab5e18fcb136590ce7c4a0ac95...b6effb05e454b25005698d916606bdc6ffcbf961)

Updates `getsentry/craft/.github/workflows/changelog-preview.yml` from 2.27.2 to 2.28.0
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/8fd703e550582184dafbf70d704ce33786e459e6...aeb16753a1764f3ef0768c03c499e3d2e4b7227c)

Updates `github/codeql-action/init` from 4.37.3 to 4.37.4
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/e4fba868fa4b1b91e1fdab776edc8cfbe6e9fb81...f205ea1c3313d32999d8d6a48b4f6530d4437b38)

Updates `github/codeql-action/analyze` from 4.37.3 to 4.37.4
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/e4fba868fa4b1b91e1fdab776edc8cfbe6e9fb81...f205ea1c3313d32999d8d6a48b4f6530d4437b38)

Updates `getsentry/craft` from 2.27.2 to 2.28.0
- [Release notes](https://github.com/getsentry/craft/releases)
- [Changelog](https://github.com/getsentry/craft/blob/master/CHANGELOG.md)
- [Commits](https://github.com/getsentry/craft/compare/8fd703e550582184dafbf70d704ce33786e459e6...aeb16753a1764f3ef0768c03c499e3d2e4b7227c)

---
updated-dependencies:
- dependency-name: actions/setup-java
  dependency-version: 5.7.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: getsentry/craft/.github/workflows/changelog-preview.yml
  dependency-version: 2.28.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
- dependency-name: github/codeql-action/init
  dependency-version: 4.37.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.37.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: getsentry/craft
  dependency-version: 2.28.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/changelog-preview.yml             | 2 +-
 .github/workflows/codeql-analysis.yml               | 6 +++---
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/release.yml                       | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 17 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 513d879513f..8b85fcb87bd 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -33,7 +33,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 04b5d26e6c2..2b04dfb35db 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -25,7 +25,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
index c2ab5983c3a..c6cf9f36bd2 100644
--- a/.github/workflows/changelog-preview.yml
+++ b/.github/workflows/changelog-preview.yml
@@ -15,5 +15,5 @@ permissions:
 
 jobs:
   changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@8fd703e550582184dafbf70d704ce33786e459e6 # v2
+    uses: getsentry/craft/.github/workflows/changelog-preview.yml@aeb16753a1764f3ef0768c03c499e3d2e4b7227c # v2
     secrets: inherit
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 33566af8602..d046c593a3c 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -25,7 +25,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@e4fba868fa4b1b91e1fdab776edc8cfbe6e9fb81 # pin@v2
+        uses: github/codeql-action/init@f205ea1c3313d32999d8d6a48b4f6530d4437b38 # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@e4fba868fa4b1b91e1fdab776edc8cfbe6e9fb81 # pin@v2
+        uses: github/codeql-action/analyze@f205ea1c3313d32999d8d6a48b4f6530d4437b38 # pin@v2
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index dcb0ca09dbe..7362b4d141b 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -14,7 +14,7 @@ jobs:
         uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
 
       - name: Set up Java
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index c0ca07b7387..bb9cfd2b3f5 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -13,7 +13,7 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index 72d7e9dd7c5..2c3d4415df8 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -14,7 +14,7 @@ jobs:
           submodules: 'recursive'
 
       - name: set up JDK 17
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 199d22122df..36137a5c6d4 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -32,7 +32,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
@@ -82,7 +82,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index 835019d1f89..faa5b2e89e7 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -23,7 +23,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Setup Java Version
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: "temurin"
           java-version: "17"
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 2ee76141eb2..3aa94fc2aff 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -30,7 +30,7 @@ jobs:
         uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
 
       - name: Set up Java 17
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 0241cb07536..c23b9bf6b79 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -27,7 +27,7 @@ jobs:
           submodules: 'recursive'
 
       - name: 'Set up Java: 17'
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index 32451c1a8cb..f6b5b6848b1 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -20,7 +20,7 @@ jobs:
           submodules: 'recursive'
 
       - name: Setup Java Version
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 8c79ef8e541..ce4bdb23b9c 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -34,7 +34,7 @@ jobs:
           fetch-depth: 0
           submodules: 'recursive'
       - name: Prepare release
-        uses: getsentry/craft@8fd703e550582184dafbf70d704ce33786e459e6 # v2
+        uses: getsentry/craft@aeb16753a1764f3ef0768c03c499e3d2e4b7227c # v2
         env:
           GITHUB_TOKEN: ${{ steps.token.outputs.token }}
         with:
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index d41de896e24..28426e580d9 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index 539301099d7..becfb3874a8 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index cd12cb80809..18bbd54ec4d 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -45,7 +45,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index db1a29df14e..8b0dece8561 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -112,7 +112,7 @@ jobs:
           python3 -m pip install -r requirements.txt
 
       - name: Set up Java
-        uses: actions/setup-java@03ad4de0992f5dab5e18fcb136590ce7c4a0ac95 # v5
+        uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
         with:
           distribution: 'temurin'
           java-version: '17'

From ca72eb94989d131cab3857d760002499f7ee46f6 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 4 Aug 2026 08:36:12 +0000
Subject: [PATCH 357/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.16.1 (#5879)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 ++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a79d7527bd0..8ced1fee970 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,6 +19,12 @@
 - Batch and coalesce scope-persistence disk writes to reduce startup cost ([#5791](https://github.com/getsentry/sentry-java/pull/5791))
   - Scope mutations are now coalesced (latest value per field) and breadcrumbs are appended in batches behind a single fsync, instead of one synchronous disk write per mutation.
 
+### Dependencies
+
+- Bump Native SDK from v0.16.0 to v0.16.1 ([#5879](https://github.com/getsentry/sentry-java/pull/5879))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0161)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.16.0...0.16.1)
+
 ## 8.51.0
 
 ### Features
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 32bf6b736d9..498e4c0e3ee 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -169,7 +169,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.16.0" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.16.1" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 926b41486aac0715e5e10c341ccfdd10aad08153 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Tue, 4 Aug 2026 10:50:04 +0200
Subject: [PATCH 358/391] fix(android): Reduce SQLite cursor SDK crash false
 positives (#5883)

Replace Kotlin interface delegation in SentryCrossProcessCursor with Android's CursorWrapper for ordinary Cursor methods. This keeps lazy-query span instrumentation on getCount, onMove, and fillWindow, but avoids generating Sentry-owned methods such as getString for pass-through cursor calls.

When app database code throws from those ordinary cursor methods, the stack should now point at Android's cursor wrapper and the underlying SQLite failure instead of making SDK crash detection treat the event as caused by Sentry's SQLite integration.

Co-authored-by: OpenCode <noreply@opencode.ai>
---
 .../android/sqlite/SentryCrossProcessCursor.kt       | 10 ++++++----
 .../android/sqlite/SentryCrossProcessCursorTest.kt   | 12 +++++++-----
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentryCrossProcessCursor.kt b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentryCrossProcessCursor.kt
index f5f8424aca3..01da8c476db 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentryCrossProcessCursor.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/android/sqlite/SentryCrossProcessCursor.kt
@@ -2,20 +2,20 @@ package io.sentry.android.sqlite
 
 import android.database.CrossProcessCursor
 import android.database.CursorWindow
+import android.database.CursorWrapper
 
 /*
  * SQLiteCursor executes the query lazily, when one of getCount() and onMove() is called.
  * Also, by docs, fillWindow() can be used to fill the cursor with data.
  * So we wrap these methods to create a span.
- * SQLiteCursor is never used directly in the code, but only the Cursor interface.
- *  This means we can use CrossProcessCursor - that extends Cursor - as wrapper, since
- *   CrossProcessCursor is an interface and we can use Kotlin delegation.
+ * Ordinary Cursor methods are delegated through CursorWrapper to avoid adding Sentry frames to
+ * app database exceptions that the wrapper did not instrument.
  */
 internal class SentryCrossProcessCursor(
   private val delegate: CrossProcessCursor,
   private val spans: OpenHelperSpans,
   private val sql: String,
-) : CrossProcessCursor by delegate {
+) : CursorWrapper(delegate), CrossProcessCursor {
   // We have to start the span only the first time, regardless of how many times its methods get
   // called.
   private var isSpanStarted = false
@@ -36,6 +36,8 @@ internal class SentryCrossProcessCursor(
     return spans.performSql(sql) { delegate.onMove(oldPosition, newPosition) }
   }
 
+  override fun getWindow(): CursorWindow? = delegate.window
+
   override fun fillWindow(position: Int, window: CursorWindow?) {
     if (isSpanStarted) {
       return delegate.fillWindow(position, window)
diff --git a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentryCrossProcessCursorTest.kt b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentryCrossProcessCursorTest.kt
index 27eff29c9f3..ba77b2398c7 100644
--- a/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentryCrossProcessCursorTest.kt
+++ b/sentry-android-sqlite/src/test/java/io/sentry/android/sqlite/SentryCrossProcessCursorTest.kt
@@ -1,6 +1,7 @@
 package io.sentry.android.sqlite
 
 import android.database.CrossProcessCursor
+import android.database.CursorWrapper
 import io.sentry.IScopes
 import io.sentry.ISpan
 import io.sentry.SentryOptions
@@ -52,13 +53,14 @@ class SentryCrossProcessCursorTest {
 
     cursor.fillWindow(0, mock())
     verify(fixture.mockCursor).fillWindow(eq(0), any())
+  }
 
-    // Let's verify other methods are delegated, even if not explicitly
-    cursor.close()
-    verify(fixture.mockCursor).close()
+  @Test
+  fun `ordinary cursor methods are delegated by Android CursorWrapper`() {
+    val getStringMethod =
+      SentryCrossProcessCursor::class.java.getMethod("getString", Int::class.javaPrimitiveType!!)
 
-    cursor.getString(1)
-    verify(fixture.mockCursor).getString(eq(1))
+    assertEquals(CursorWrapper::class.java, getStringMethod.declaringClass)
   }
 
   @Test

From a28ee629977140ac9ed8543a6ee9c0ba03ca423b Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 5 Aug 2026 09:52:36 +0200
Subject: [PATCH 359/391] perf: Drop pending timer tasks on shutdown to unblock
 close (JAVA-653) (#5851)

* perf: Drop pending timer tasks on shutdown to unblock close (JAVA-653)

The timer executor is shut down by Scopes.close() via shutdown() followed
by awaitTermination(). ScheduledThreadPoolExecutor keeps queued delayed
tasks across shutdown() by default, so awaitTermination() blocks for the
full shutdown timeout (2s by default) whenever a long timeout is still
pending: an unfinished transaction's idle/deadline timer, the 30s
LifecycleWatcher end-session task, or a rate limit lifted notification.

Those tasks are discarded by the subsequent shutdownNow() anyway, so
dropping them upfront is behaviour preserving and only saves the wait.
This only affects shutdown(), so the SDK restart path that intentionally
leaves the timer executor running is unaffected.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* changelog

* test: Drop SentryExecutorService shutdown policy tests (JAVA-653)

One test only asserted the setter took effect and the other timed
close() against a wall-clock bound, which is flaky on loaded CI. The
comment on setExecuteExistingDelayedTasksAfterShutdownPolicy explains
why the policy is set, which is enough to prevent someone removing it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 CHANGELOG.md                                              | 1 +
 sentry/src/main/java/io/sentry/SentryExecutorService.java | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8ced1fee970..70c9f04dee7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@
 
 ### Performance
 
+- Avoid waiting up to `shutdownTimeoutMillis` when closing the SDK with a pending transaction timeout or session-end task ([#5851](https://github.com/getsentry/sentry-java/pull/5851))
 - Use `RGB_565` instead of `ARGB_8888` for screenshot and replay capture bitmaps, halving per-frame memory usage ([#5821](https://github.com/getsentry/sentry-java/pull/5821))
 - Remove an unused lock from `SentryPerformanceProvider`, which was allocated on every cold start in `ContentProvider.onCreate` without ever being acquired ([#5871](https://github.com/getsentry/sentry-java/pull/5871))
 - Parse the app start profiling config with only the deserializer it needs instead of building a full `JsonSerializer` and `SentryOptions`, cutting 188 of 221 allocations on the main thread before `Application.onCreate` ([#5867](https://github.com/getsentry/sentry-java/pull/5867))
diff --git a/sentry/src/main/java/io/sentry/SentryExecutorService.java b/sentry/src/main/java/io/sentry/SentryExecutorService.java
index e20c0835637..e50cb032d41 100644
--- a/sentry/src/main/java/io/sentry/SentryExecutorService.java
+++ b/sentry/src/main/java/io/sentry/SentryExecutorService.java
@@ -55,6 +55,10 @@ public SentryExecutorService(final @Nullable SentryOptions options) {
     executorService.setRemoveOnCancelPolicy(removeOnCancelPolicy);
     executorService.setKeepAliveTime(keepAliveTime, keepAliveTimeUnit);
     executorService.allowCoreThreadTimeOut(true);
+    // by default shutdown() keeps queued delayed tasks, so awaitTermination blocks for the full
+    // shutdown timeout whenever a long timeout is still pending. Those tasks are discarded by the
+    // subsequent shutdownNow() anyway, so dropping them upfront only saves the wait.
+    executorService.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
   }
 
   public SentryExecutorService() {

From 02ce0502d2da42927451119ec7bfda1c310340f6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 5 Aug 2026 10:35:10 +0200
Subject: [PATCH 360/391] chore(deps): bump gradle/actions/setup-gradle (#5890)

Bumps the github-actions group with 1 update: [gradle/actions/setup-gradle](https://github.com/gradle/actions).


Updates `gradle/actions/setup-gradle` from 6.2.0 to 6.3.0
- [Release notes](https://github.com/gradle/actions/releases)
- [Commits](https://github.com/gradle/actions/compare/3f131e8634966bd73d06cc69884922b02e6faf92...9c971963bec38e04b3d30dcc455b5382be2fdbfb)

---
updated-dependencies:
- dependency-name: gradle/actions/setup-gradle
  dependency-version: 6.3.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/agp-matrix.yml                    | 2 +-
 .github/workflows/build.yml                         | 2 +-
 .github/workflows/codeql-analysis.yml               | 2 +-
 .github/workflows/enforce-license-compliance.yml    | 2 +-
 .github/workflows/format-code.yml                   | 2 +-
 .github/workflows/generate-javadocs.yml             | 2 +-
 .github/workflows/integration-tests-benchmarks.yml  | 4 ++--
 .github/workflows/integration-tests-size.yml        | 2 +-
 .github/workflows/integration-tests-ui-critical.yml | 2 +-
 .github/workflows/integration-tests-ui.yml          | 2 +-
 .github/workflows/release-build.yml                 | 2 +-
 .github/workflows/spring-boot-2-matrix.yml          | 2 +-
 .github/workflows/spring-boot-3-matrix.yml          | 2 +-
 .github/workflows/spring-boot-4-matrix.yml          | 2 +-
 .github/workflows/system-tests-backend.yml          | 2 +-
 15 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/agp-matrix.yml b/.github/workflows/agp-matrix.yml
index 8b85fcb87bd..4dc779ce812 100644
--- a/.github/workflows/agp-matrix.yml
+++ b/.github/workflows/agp-matrix.yml
@@ -39,7 +39,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 2b04dfb35db..1237b5f7d40 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -38,7 +38,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index d046c593a3c..b4ce0ce8101 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -31,7 +31,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/enforce-license-compliance.yml b/.github/workflows/enforce-license-compliance.yml
index 7362b4d141b..a7be2bdb001 100644
--- a/.github/workflows/enforce-license-compliance.yml
+++ b/.github/workflows/enforce-license-compliance.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
 
       - name: Set up Java
         uses: actions/setup-java@b6effb05e454b25005698d916606bdc6ffcbf961 # v5
diff --git a/.github/workflows/format-code.yml b/.github/workflows/format-code.yml
index bb9cfd2b3f5..7f638963fc0 100644
--- a/.github/workflows/format-code.yml
+++ b/.github/workflows/format-code.yml
@@ -19,7 +19,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/generate-javadocs.yml b/.github/workflows/generate-javadocs.yml
index 2c3d4415df8..ad33bb93e7a 100644
--- a/.github/workflows/generate-javadocs.yml
+++ b/.github/workflows/generate-javadocs.yml
@@ -20,7 +20,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
 
       - name: Generate Aggregate Javadocs
         run: |
diff --git a/.github/workflows/integration-tests-benchmarks.yml b/.github/workflows/integration-tests-benchmarks.yml
index 36137a5c6d4..66e4498dcb5 100644
--- a/.github/workflows/integration-tests-benchmarks.yml
+++ b/.github/workflows/integration-tests-benchmarks.yml
@@ -38,7 +38,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
@@ -88,7 +88,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-size.yml b/.github/workflows/integration-tests-size.yml
index faa5b2e89e7..3e76c951f86 100644
--- a/.github/workflows/integration-tests-size.yml
+++ b/.github/workflows/integration-tests-size.yml
@@ -36,7 +36,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-ui-critical.yml b/.github/workflows/integration-tests-ui-critical.yml
index 3aa94fc2aff..dd99f8c6b7c 100644
--- a/.github/workflows/integration-tests-ui-critical.yml
+++ b/.github/workflows/integration-tests-ui-critical.yml
@@ -36,7 +36,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index c23b9bf6b79..815611507d1 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -33,7 +33,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/release-build.yml b/.github/workflows/release-build.yml
index f6b5b6848b1..a1f47577c5f 100644
--- a/.github/workflows/release-build.yml
+++ b/.github/workflows/release-build.yml
@@ -26,7 +26,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
 
       - name: Build artifacts
         run: make publish
diff --git a/.github/workflows/spring-boot-2-matrix.yml b/.github/workflows/spring-boot-2-matrix.yml
index 28426e580d9..66847c8c792 100644
--- a/.github/workflows/spring-boot-2-matrix.yml
+++ b/.github/workflows/spring-boot-2-matrix.yml
@@ -58,7 +58,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/spring-boot-3-matrix.yml b/.github/workflows/spring-boot-3-matrix.yml
index becfb3874a8..3ccfba65c4c 100644
--- a/.github/workflows/spring-boot-3-matrix.yml
+++ b/.github/workflows/spring-boot-3-matrix.yml
@@ -58,7 +58,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/spring-boot-4-matrix.yml b/.github/workflows/spring-boot-4-matrix.yml
index 18bbd54ec4d..f75f31e38ef 100644
--- a/.github/workflows/spring-boot-4-matrix.yml
+++ b/.github/workflows/spring-boot-4-matrix.yml
@@ -58,7 +58,7 @@ jobs:
           key: build-logic-${{ hashFiles('buildSrc/src/**', 'buildSrc/build.gradle.kts','buildSrc/settings.gradle.kts') }}
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
diff --git a/.github/workflows/system-tests-backend.yml b/.github/workflows/system-tests-backend.yml
index 8b0dece8561..12d84c0ef99 100644
--- a/.github/workflows/system-tests-backend.yml
+++ b/.github/workflows/system-tests-backend.yml
@@ -118,7 +118,7 @@ jobs:
           java-version: '17'
 
       - name: Setup Gradle
-        uses: gradle/actions/setup-gradle@3f131e8634966bd73d06cc69884922b02e6faf92 # v6.2.0
+        uses: gradle/actions/setup-gradle@9c971963bec38e04b3d30dcc455b5382be2fdbfb # v6.3.0
         with:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 

From 52bd5a78e2d60221a77e72d56f0f2975b55fa10e Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Wed, 5 Aug 2026 11:09:47 +0200
Subject: [PATCH 361/391] fix(android): Defer frame metrics reflection during
 init (#5886)

Moves Choreographer field lookup out of the frame metrics collector constructor so that Sentry.init() doesn't synchronously perform framework reflection. Helps us reduce the likelihood of another common class of Sentry.init() ANRs (see [here](https://sentry.sentry.io/issues/6138715212/?project=4506812075540480&referrer=seer.agent.in-chat-link)).

Behavior change from the user's perspective should usually be non-existant, and minor in the worst case. The choreographer and choreographerLastFrameTimeField properties are still initialized by a main-thread Handler post made during collector construction, before later startCollection() calls post frame-listener registration work to the same main looper. Since those main-looper tasks run in order, the Choreographer fallback should be populated before any collected frame or pending-frame interpolation normally needs it. If it's not ready yet, the failure mode is a missed/less precise first pending-frame calculation rather than a crash.

Co-Authored-By: OpenCode <noreply@opencode.ai>
---
 CHANGELOG.md                                  |  1 +
 .../util/SentryFrameMetricsCollector.java     | 34 ++++++----
 .../util/SentryFrameMetricsCollectorTest.kt   | 66 +++++++++++--------
 3 files changed, 60 insertions(+), 41 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 70c9f04dee7..8c0e71517d2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@
 
 ### Performance
 
+- Defer `Choreographer` reflection for frame metrics collection to avoid blocking the main thread during `Sentry.init` ([#5886](https://github.com/getsentry/sentry-java/pull/5886))
 - Avoid waiting up to `shutdownTimeoutMillis` when closing the SDK with a pending transaction timeout or session-end task ([#5851](https://github.com/getsentry/sentry-java/pull/5851))
 - Use `RGB_565` instead of `ARGB_8888` for screenshot and replay capture bitmaps, halving per-frame memory usage ([#5821](https://github.com/getsentry/sentry-java/pull/5821))
 - Remove an unused lock from `SentryPerformanceProvider`, which was allocated on every cold start in `ContentProvider.onCreate` without ever being acquired ([#5871](https://github.com/getsentry/sentry-java/pull/5871))
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
index 4f6b486f3a1..2c0ae246558 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollector.java
@@ -56,8 +56,8 @@ public final class SentryFrameMetricsCollector implements Application.ActivityLi
   private final WindowFrameMetricsManager windowFrameMetricsManager;
 
   private @Nullable Window.OnFrameMetricsAvailableListener frameMetricsAvailableListener;
-  private @Nullable Choreographer choreographer;
-  private @Nullable Field choreographerLastFrameTimeField;
+  private volatile @Nullable Choreographer choreographer;
+  private volatile @Nullable Field choreographerLastFrameTimeField;
   private long lastFrameStartNanos = 0;
   private long lastFrameEndNanos = 0;
 
@@ -126,7 +126,8 @@ public SentryFrameMetricsCollector(
     // Most considerations regarding timestamps of frames are inspired from JankStats library:
     // https://cs.android.com/androidx/platform/frameworks/support/+/androidx-main:metrics/metrics-performance/src/main/java/androidx/metrics/performance/JankStatsApi24Impl.kt
 
-    // The Choreographer instance must be accessed on the main thread
+    // The Choreographer instance should be initialized asynchronously on the main thread to avoid
+    // reflection during SDK init.
     new Handler(Looper.getMainLooper())
         .post(
             () -> {
@@ -138,15 +139,19 @@ public SentryFrameMetricsCollector(
                     "Error retrieving Choreographer instance. Slow and frozen frames will not be reported.",
                     e);
               }
+
+              // Let's get the last frame timestamp from the choreographer private field
+              try {
+                choreographerLastFrameTimeField =
+                    Choreographer.class.getDeclaredField("mLastFrameTimeNanos");
+                choreographerLastFrameTimeField.setAccessible(true);
+              } catch (NoSuchFieldException e) {
+                logger.log(
+                    SentryLevel.ERROR,
+                    "Unable to get the frame timestamp from the choreographer: ",
+                    e);
+              }
             });
-    // Let's get the last frame timestamp from the choreographer private field
-    try {
-      choreographerLastFrameTimeField = Choreographer.class.getDeclaredField("mLastFrameTimeNanos");
-      choreographerLastFrameTimeField.setAccessible(true);
-    } catch (NoSuchFieldException e) {
-      logger.log(
-          SentryLevel.ERROR, "Unable to get the frame timestamp from the choreographer: ", e);
-    }
 
     frameMetricsAvailableListener =
         (window, frameMetrics, dropCountSinceLastInvocation) -> {
@@ -165,7 +170,8 @@ public SentryFrameMetricsCollector(
           final long delayNanos = Math.max(0, cpuDuration - expectedFrameDuration);
 
           long startTime = getFrameStartTimestamp(frameMetrics);
-          // If we couldn't get the timestamp through reflection, we use current time
+          // If we couldn't get the timestamp through FrameMetrics or reflection, we use the current
+          // time.
           if (startTime < 0) {
             startTime = now - cpuDuration;
           }
@@ -217,8 +223,8 @@ public static boolean isSlow(long frameDuration, final long expectedFrameDuratio
   }
 
   /**
-   * Return the internal timestamp in the choreographer of the last frame start timestamp through
-   * reflection. On Android O the value is read from the frameMetrics itself.
+   * Return the frame start timestamp. On API 26+, this value is read directly from {@link
+   * FrameMetrics}; older APIs use the reflected Choreographer timestamp.
    */
   @SuppressLint("NewApi")
   private long getFrameStartTimestamp(final @NotNull FrameMetrics frameMetrics) {
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt
index f90c07b70e6..334ce229066 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/internal/util/SentryFrameMetricsCollectorTest.kt
@@ -19,7 +19,6 @@ import io.sentry.test.getCtor
 import io.sentry.test.getProperty
 import io.sentry.test.injectForField
 import java.lang.ref.WeakReference
-import java.lang.reflect.Field
 import java.util.concurrent.TimeUnit
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -302,18 +301,41 @@ class SentryFrameMetricsCollectorTest {
   }
 
   @Test
-  fun `collector accesses choreographer instance on creation on main thread`() {
+  fun `collector accesses choreographer instance and field asynchronously on main thread`() {
     val collector = fixture.getSut(context)
-    val field: Field? = collector.getProperty("choreographerLastFrameTimeField")
+
+    val field: Any? = collector.getProperty("choreographerLastFrameTimeField")
     var choreographer: Choreographer? = collector.getProperty("choreographer")
-    // Choreographer instance is accessed on main thread, but the field accessor happens in whatever
-    // thread created the collector
-    assertNotNull(field)
+
     assertNull(choreographer)
+    assertNull(field)
+
     // Execute all posted tasks
     Shadows.shadowOf(Looper.getMainLooper()).idle()
     choreographer = collector.getProperty("choreographer")
     assertNotNull(choreographer)
+    assertNotNull(collector.getProperty<Any?>("choreographerLastFrameTimeField"))
+  }
+
+  // Frame callbacks on API 26+ read their per-frame start timestamp directly from FrameMetrics,
+  // which can make the Choreographer fallback look like it should be specific to APIs < 26.
+  // But SpanFrameMetricsCollector separately calls getLastKnownFrameStartTimeNanos() on every
+  // API level for pending-frame interpolation, so API 26+ still needs the Choreographer
+  // fallback to be initialized.
+  @Test
+  fun `collector keeps choreographer fallback available on version O+`() {
+    val buildInfo =
+      mock<BuildInfoProvider> { whenever(it.sdkInfoVersion).thenReturn(Build.VERSION_CODES.O) }
+    val collector = fixture.getSut(context, buildInfo)
+
+    Shadows.shadowOf(Looper.getMainLooper()).idle()
+
+    val choreographer = collector.getProperty<Choreographer>("choreographer")
+    assertNotNull(collector.getProperty<Any?>("choreographerLastFrameTimeField"))
+
+    choreographer.injectForField("mLastFrameTimeNanos", 100)
+
+    assertEquals(100, collector.getLastKnownFrameStartTimeNanos())
   }
 
   @Test
@@ -621,10 +643,6 @@ class SentryFrameMetricsCollectorTest {
     // emit a fast frame (21ns cpu time — well under 16ms budget)
     listener.onFrameMetricsAvailable(createMockWindow(), createMockFrameMetrics(), 0)
 
-    // choreographer is at end of range so no pending delay
-    val choreographer = collector.getProperty<Choreographer>("choreographer")
-    choreographer.injectForField("mLastFrameTimeNanos", TimeUnit.SECONDS.toNanos(1))
-
     val result = collector.getFramesDelay(0, TimeUnit.SECONDS.toNanos(1))
     assertEquals(0.0, result.delaySeconds)
     assertEquals(0, result.framesContributingToDelayCount)
@@ -643,22 +661,23 @@ class SentryFrameMetricsCollectorTest {
     // emit a slow frame (~100ms extra = ~116ms total, well over 16ms budget)
     listener.onFrameMetricsAvailable(
       createMockWindow(),
-      createMockFrameMetrics(extraCpuDurationNanos = TimeUnit.MILLISECONDS.toNanos(100)),
+      createMockFrameMetrics(
+        extraCpuDurationNanos = TimeUnit.MILLISECONDS.toNanos(100),
+        intendedVsyncTimestampNanos = TimeUnit.SECONDS.toNanos(1),
+      ),
       0,
     )
 
     // emit a frozen frame (~1000ms extra = ~1016ms total, well over 700ms)
     listener.onFrameMetricsAvailable(
       createMockWindow(),
-      createMockFrameMetrics(extraCpuDurationNanos = TimeUnit.MILLISECONDS.toNanos(1000)),
+      createMockFrameMetrics(
+        extraCpuDurationNanos = TimeUnit.MILLISECONDS.toNanos(1000),
+        intendedVsyncTimestampNanos = TimeUnit.SECONDS.toNanos(2),
+      ),
       0,
     )
 
-    // choreographer is at end of range so no pending delay
-    Shadows.shadowOf(Looper.getMainLooper()).idle()
-    val choreographer = collector.getProperty<Choreographer>("choreographer")
-    choreographer.injectForField("mLastFrameTimeNanos", TimeUnit.SECONDS.toNanos(5))
-
     val result = collector.getFramesDelay(0, TimeUnit.SECONDS.toNanos(5))
     assertTrue(result.delaySeconds > 0)
     assertEquals(2, result.framesContributingToDelayCount)
@@ -681,11 +700,6 @@ class SentryFrameMetricsCollectorTest {
       0,
     )
 
-    // choreographer is at end of range
-    Shadows.shadowOf(Looper.getMainLooper()).idle()
-    val choreographer = collector.getProperty<Choreographer>("choreographer")
-    choreographer.injectForField("mLastFrameTimeNanos", TimeUnit.SECONDS.toNanos(5))
-
     // The frame's delay interval is roughly [~16ms, ~1000ms].
     // Query from 500ms so the range clips the delay interval in half.
     val queryStart = TimeUnit.MILLISECONDS.toNanos(500)
@@ -708,7 +722,6 @@ class SentryFrameMetricsCollectorTest {
     Shadows.shadowOf(Looper.getMainLooper()).idle()
     val listener =
       collector.getProperty<Window.OnFrameMetricsAvailableListener>("frameMetricsAvailableListener")
-    val choreographer = collector.getProperty<Choreographer>("choreographer")
 
     collector.startCollection(mock())
 
@@ -720,8 +733,6 @@ class SentryFrameMetricsCollectorTest {
     whenever(frameMetrics1.getMetric(FrameMetrics.INTENDED_VSYNC_TIMESTAMP)).thenReturn(t0)
     listener.onFrameMetricsAvailable(createMockWindow(), frameMetrics1, 0)
 
-    choreographer.injectForField("mLastFrameTimeNanos", t0 + TimeUnit.SECONDS.toNanos(1))
-
     // verify frame exists
     val resultBefore = collector.getFramesDelay(t0, t0 + TimeUnit.SECONDS.toNanos(1))
     assertEquals(1, resultBefore.framesContributingToDelayCount)
@@ -734,7 +745,6 @@ class SentryFrameMetricsCollectorTest {
     listener.onFrameMetricsAvailable(createMockWindow(), frameMetrics2, 0)
 
     // the first frame should have been pruned (>5min old)
-    choreographer.injectForField("mLastFrameTimeNanos", t1 + TimeUnit.SECONDS.toNanos(1))
     val resultAfter = collector.getFramesDelay(t0, t0 + TimeUnit.SECONDS.toNanos(1))
     assertEquals(0, resultAfter.framesContributingToDelayCount)
   }
@@ -762,6 +772,7 @@ class SentryFrameMetricsCollectorTest {
     syncNanos: Long = 6,
     extraCpuDurationNanos: Long = 0,
     totalDurationNanos: Long = 60,
+    intendedVsyncTimestampNanos: Long = 50,
   ): FrameMetrics {
     val frameMetrics = mock<FrameMetrics>()
     whenever(frameMetrics.getMetric(FrameMetrics.UNKNOWN_DELAY_DURATION))
@@ -774,7 +785,8 @@ class SentryFrameMetricsCollectorTest {
     whenever(frameMetrics.getMetric(FrameMetrics.DRAW_DURATION)).thenReturn(drawNanos)
     whenever(frameMetrics.getMetric(FrameMetrics.SYNC_DURATION)).thenReturn(syncNanos)
     whenever(frameMetrics.getMetric(FrameMetrics.TOTAL_DURATION)).thenReturn(totalDurationNanos)
-    whenever(frameMetrics.getMetric(FrameMetrics.INTENDED_VSYNC_TIMESTAMP)).thenReturn(50)
+    whenever(frameMetrics.getMetric(FrameMetrics.INTENDED_VSYNC_TIMESTAMP))
+      .thenReturn(intendedVsyncTimestampNanos)
     return frameMetrics
   }
 }

From 0216f816161f586f964bebc2336a965959471c37 Mon Sep 17 00:00:00 2001
From: Alexander Tarasov <alex.tarasov@sentry.io>
Date: Wed, 5 Aug 2026 12:01:38 +0200
Subject: [PATCH 362/391] ci: Remove disabled changelog-preview workflow
 (#5889)

changelog-preview.yml is disabled_manually on GitHub and unused. Rather
than fixing its secrets: inherit usage, remove the workflow entirely,
consistent with how other getsentry repos are dropping this disabled
workflow.

Refs VULN-2260

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
---
 .github/workflows/changelog-preview.yml | 19 -------------------
 1 file changed, 19 deletions(-)
 delete mode 100644 .github/workflows/changelog-preview.yml

diff --git a/.github/workflows/changelog-preview.yml b/.github/workflows/changelog-preview.yml
deleted file mode 100644
index c6cf9f36bd2..00000000000
--- a/.github/workflows/changelog-preview.yml
+++ /dev/null
@@ -1,19 +0,0 @@
-name: Changelog Preview
-on:
-  pull_request:
-    types:
-    - opened
-    - synchronize
-    - reopened
-    - edited
-    - labeled
-    - unlabeled
-permissions:
-  contents: write
-  pull-requests: write
-  statuses: write
-
-jobs:
-  changelog-preview:
-    uses: getsentry/craft/.github/workflows/changelog-preview.yml@aeb16753a1764f3ef0768c03c499e3d2e4b7227c # v2
-    secrets: inherit

From fb4dfe96c2fa5645bc70e9c0d076e5977e51b992 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 5 Aug 2026 13:12:12 +0200
Subject: [PATCH 363/391] docs: Remove build command from agent instructions
 (#5873)

Drop the "Build entire project" command from AGENTS.md Essential
Commands so agents aren't instructed to run a full ./gradlew build,
which is an expensive step not needed for the documented workflow.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 AGENTS.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/AGENTS.md b/AGENTS.md
index de4e29376ad..4f938ceff2d 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -34,9 +34,6 @@ The project uses **Gradle** with Kotlin DSL. Key build files:
 # Run all tests and linter
 ./gradlew check
 
-# Build entire project
-./gradlew build
-
 # Generate documentation
 ./gradlew aggregateJavadocs
 ```

From 998c5389c17cde71b0ee1e70eb82ba02491ff11a Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Wed, 5 Aug 2026 13:22:56 +0200
Subject: [PATCH 364/391] fix(core): Restore directory processor interrupt flag
 (#5884)

Restore the interrupt status when the inter-envelope processing delay is interrupted so callers can observe the interruption after directory processing returns.

Add regression coverage for the interrupted delay path.

Fixes JAVA-666
Co-Authored-By: OpenCode <noreply@opencode.ai>
---
 CHANGELOG.md                                  |  1 +
 .../java/io/sentry/DirectoryProcessor.java    |  7 ++++++
 .../java/io/sentry/DirectoryProcessorTest.kt  | 23 +++++++++++++++++++
 3 files changed, 31 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8c0e71517d2..c405455aaf1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Restore the interrupt flag when cached envelope processing is interrupted between files ([#5884](https://github.com/getsentry/sentry-java/issues/5884))
 - Prevent inflated cold app start when the OS spawns the process in the background (e.g. FCM push) on API 35+ ([#5841](https://github.com/getsentry/sentry-java/pull/5841), [#5880](https://github.com/getsentry/sentry-java/pull/5880))
 - Preserve single-sample ANR profile chunks so profiles remain available on ANR events ([#5872](https://github.com/getsentry/sentry-java/pull/5872))
 - Avoid a CPU busy-loop when recording discarded log or metric envelopes under rate limiting ([#5835](https://github.com/getsentry/sentry-java/pull/5835))
diff --git a/sentry/src/main/java/io/sentry/DirectoryProcessor.java b/sentry/src/main/java/io/sentry/DirectoryProcessor.java
index 1bc277b18cd..17f65bb8c76 100644
--- a/sentry/src/main/java/io/sentry/DirectoryProcessor.java
+++ b/sentry/src/main/java/io/sentry/DirectoryProcessor.java
@@ -93,6 +93,13 @@ public void processDirectory(final @NotNull File directory) {
         // InterruptedException will be handled by the outer try-catch
         Thread.sleep(ENVELOPE_PROCESSING_DELAY);
       }
+    } catch (InterruptedException e) {
+      Thread.currentThread().interrupt();
+      logger.log(
+          SentryLevel.INFO,
+          e,
+          "Thread interrupted during processing '%s'",
+          directory.getAbsolutePath());
     } catch (Throwable e) {
       logger.log(SentryLevel.ERROR, e, "Failed processing '%s'", directory.getAbsolutePath());
     }
diff --git a/sentry/src/test/java/io/sentry/DirectoryProcessorTest.kt b/sentry/src/test/java/io/sentry/DirectoryProcessorTest.kt
index ca890f13f90..970a1a99bf6 100644
--- a/sentry/src/test/java/io/sentry/DirectoryProcessorTest.kt
+++ b/sentry/src/test/java/io/sentry/DirectoryProcessorTest.kt
@@ -1,5 +1,6 @@
 package io.sentry
 
+import com.google.common.truth.Truth.assertThat
 import io.sentry.hints.ApplyScopeData
 import io.sentry.hints.Enqueable
 import io.sentry.hints.Retryable
@@ -135,6 +136,28 @@ class DirectoryProcessorTest {
     verify(fixture.scopes).captureEvent(any(), anyOrNull<Hint>())
   }
 
+  @Test
+  fun `when envelope processing delay is interrupted, restores interrupt flag`() {
+    getTempEnvelope("envelope-event-attachment.txt")
+    val sut =
+      object : DirectoryProcessor(fixture.scopes, fixture.logger, 500, 30) {
+        override fun processFile(file: File, hint: Hint) = Unit
+
+        override fun isRelevantFileName(fileName: String): Boolean = true
+      }
+
+    Thread.currentThread().interrupt()
+    val interruptFlagRestored =
+      try {
+        sut.processDirectory(file)
+        Thread.currentThread().isInterrupted
+      } finally {
+        Thread.interrupted()
+      }
+
+    assertThat(interruptFlagRestored).isTrue()
+  }
+
   private fun getTempEnvelope(fileName: String): String {
     val testFile = this::class.java.classLoader.getResource(fileName)
     val testFileBytes = testFile!!.readBytes()

From f2802aaa1da185da00039f725b360b6b735ead21 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 5 Aug 2026 15:21:36 +0200
Subject: [PATCH 365/391] perf: Let HostnameCache worker thread idle out
 (JAVA-653) (#5817)

* perf: Let HostnameCache worker thread idle out (JAVA-653)

HostnameCache used Executors.newSingleThreadExecutor, whose worker
thread stays alive for the life of the process even though the cache
refreshes at most once every 5 hours. Use a ThreadPoolExecutor with a
keep-alive and allowCoreThreadTimeOut(true) so the thread terminates
when idle and is recreated on the next refresh. Keeping a dedicated
executor (rather than sharing one) preserves the blocking
future.get(1s) timeout behavior.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../main/java/io/sentry/HostnameCache.java    | 21 ++++++++--
 .../test/java/io/sentry/HostnameCacheTest.kt  | 41 +++++++++++++++++++
 3 files changed, 60 insertions(+), 3 deletions(-)
 create mode 100644 sentry/src/test/java/io/sentry/HostnameCacheTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c405455aaf1..634076ff692 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,6 +21,7 @@
 - Parse the app start profiling config with only the deserializer it needs instead of building a full `JsonSerializer` and `SentryOptions`, cutting 188 of 221 allocations on the main thread before `Application.onCreate` ([#5867](https://github.com/getsentry/sentry-java/pull/5867))
 - Batch and coalesce scope-persistence disk writes to reduce startup cost ([#5791](https://github.com/getsentry/sentry-java/pull/5791))
   - Scope mutations are now coalesced (latest value per field) and breadcrumbs are appended in batches behind a single fsync, instead of one synchronous disk write per mutation.
+- Reduce the number of SDK threads: the `HostnameCache` worker thread now times out while idle instead of staying alive for the whole process lifetime ([#5817](https://github.com/getsentry/sentry-java/pull/5817))
 
 ### Dependencies
 
diff --git a/sentry/src/main/java/io/sentry/HostnameCache.java b/sentry/src/main/java/io/sentry/HostnameCache.java
index beeb6f2d1b9..56cc0c2e845 100644
--- a/sentry/src/main/java/io/sentry/HostnameCache.java
+++ b/sentry/src/main/java/io/sentry/HostnameCache.java
@@ -6,9 +6,10 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
@@ -34,6 +35,9 @@ public final class HostnameCache {
   /** Time before the get hostname operation times out (in ms). */
   private static final long GET_HOSTNAME_TIMEOUT = TimeUnit.SECONDS.toMillis(1);
 
+  /** How long the worker thread may stay idle before it self-terminates. */
+  private static final long THREAD_KEEP_ALIVE_SECONDS = 30;
+
   private static volatile @Nullable HostnameCache INSTANCE;
   private static final @NotNull AutoClosableReentrantLock staticLock =
       new AutoClosableReentrantLock();
@@ -52,8 +56,7 @@ public final class HostnameCache {
 
   private final @NotNull Callable<InetAddress> getLocalhost;
 
-  private final @NotNull ExecutorService executorService =
-      Executors.newSingleThreadExecutor(new HostnameCacheThreadFactory());
+  private final @NotNull ExecutorService executorService;
 
   public static @NotNull HostnameCache getInstance() {
     if (INSTANCE == null) {
@@ -87,6 +90,18 @@ private HostnameCache() {
   HostnameCache(long cacheDuration, final @NotNull Callable<InetAddress> getLocalhost) {
     this.cacheDuration = cacheDuration;
     this.getLocalhost = Objects.requireNonNull(getLocalhost, "getLocalhost is required");
+    // A single thread executor whose worker thread times out while idle, so no thread is kept
+    // alive between the infrequent cache refreshes.
+    final @NotNull ThreadPoolExecutor executor =
+        new ThreadPoolExecutor(
+            1,
+            1,
+            THREAD_KEEP_ALIVE_SECONDS,
+            TimeUnit.SECONDS,
+            new LinkedBlockingQueue<>(),
+            new HostnameCacheThreadFactory());
+    executor.allowCoreThreadTimeOut(true);
+    this.executorService = executor;
     updateCache();
   }
 
diff --git a/sentry/src/test/java/io/sentry/HostnameCacheTest.kt b/sentry/src/test/java/io/sentry/HostnameCacheTest.kt
new file mode 100644
index 00000000000..3cc3a52aa26
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/HostnameCacheTest.kt
@@ -0,0 +1,41 @@
+package io.sentry
+
+import com.google.common.truth.Truth.assertThat
+import io.sentry.test.getProperty
+import java.net.InetAddress
+import java.util.concurrent.ThreadPoolExecutor
+import java.util.concurrent.TimeUnit
+import kotlin.test.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.whenever
+
+class HostnameCacheTest {
+
+  private fun getSut(): HostnameCache {
+    val address = mock<InetAddress>()
+    whenever(address.canonicalHostName).thenReturn("myhost")
+    return HostnameCache(TimeUnit.HOURS.toMillis(1)) { address }
+  }
+
+  @Test
+  fun `hostname is resolved and cached`() {
+    val cache = getSut()
+    assertThat(cache.hostname).isEqualTo("myhost")
+  }
+
+  @Test
+  fun `worker thread times out while idle instead of staying alive`() {
+    val cache = getSut()
+    val executorService = cache.getProperty<ThreadPoolExecutor>("executorService")
+    assertThat(executorService.allowsCoreThreadTimeOut()).isTrue()
+    assertThat(executorService.corePoolSize).isEqualTo(1)
+    assertThat(executorService.maximumPoolSize).isEqualTo(1)
+  }
+
+  @Test
+  fun `close shuts the executor down`() {
+    val cache = getSut()
+    cache.close()
+    assertThat(cache.isClosed).isTrue()
+  }
+}

From f6f3b49d16fb6b703c1151a7a0220509b82e1c2c Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 5 Aug 2026 15:40:26 +0200
Subject: [PATCH 366/391] docs: Simplify app start profiling changelog entry
 (#5891)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The unreleased Performance entry for #5867 quoted specific allocation
counts (188 of 221). Simplify it to state the benefit — fewer main-thread
allocations — without the implementation detail.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 634076ff692..0c65290d696 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,7 +18,7 @@
 - Avoid waiting up to `shutdownTimeoutMillis` when closing the SDK with a pending transaction timeout or session-end task ([#5851](https://github.com/getsentry/sentry-java/pull/5851))
 - Use `RGB_565` instead of `ARGB_8888` for screenshot and replay capture bitmaps, halving per-frame memory usage ([#5821](https://github.com/getsentry/sentry-java/pull/5821))
 - Remove an unused lock from `SentryPerformanceProvider`, which was allocated on every cold start in `ContentProvider.onCreate` without ever being acquired ([#5871](https://github.com/getsentry/sentry-java/pull/5871))
-- Parse the app start profiling config with only the deserializer it needs instead of building a full `JsonSerializer` and `SentryOptions`, cutting 188 of 221 allocations on the main thread before `Application.onCreate` ([#5867](https://github.com/getsentry/sentry-java/pull/5867))
+- Reduce main-thread allocations when parsing the app start profiling config ([#5867](https://github.com/getsentry/sentry-java/pull/5867))
 - Batch and coalesce scope-persistence disk writes to reduce startup cost ([#5791](https://github.com/getsentry/sentry-java/pull/5791))
   - Scope mutations are now coalesced (latest value per field) and breadcrumbs are appended in batches behind a single fsync, instead of one synchronous disk write per mutation.
 - Reduce the number of SDK threads: the `HostnameCache` worker thread now times out while idle instead of staying alive for the whole process lifetime ([#5817](https://github.com/getsentry/sentry-java/pull/5817))

From 796047a6054c10556286d8b161e9634fa9880bf5 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Wed, 5 Aug 2026 16:15:05 +0200
Subject: [PATCH 367/391] fix(android): Fix CHANGELOG entries ahead of 8.52.0
 release (#5892)

---
 CHANGELOG.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0c65290d696..fe246b62787 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,7 +4,8 @@
 
 ### Fixes
 
-- Restore the interrupt flag when cached envelope processing is interrupted between files ([#5884](https://github.com/getsentry/sentry-java/issues/5884))
+- Restore the interrupt flag when cached envelope processing is interrupted between files ([#5884](https://github.com/getsentry/sentry-java/pull/5884))
+- Reduce false-positive SDK crash attribution for host app SQLite cursor crashes ([#5883](https://github.com/getsentry/sentry-java/pull/5883))
 - Prevent inflated cold app start when the OS spawns the process in the background (e.g. FCM push) on API 35+ ([#5841](https://github.com/getsentry/sentry-java/pull/5841), [#5880](https://github.com/getsentry/sentry-java/pull/5880))
 - Preserve single-sample ANR profile chunks so profiles remain available on ANR events ([#5872](https://github.com/getsentry/sentry-java/pull/5872))
 - Avoid a CPU busy-loop when recording discarded log or metric envelopes under rate limiting ([#5835](https://github.com/getsentry/sentry-java/pull/5835))
@@ -14,7 +15,7 @@
 
 ### Performance
 
-- Defer `Choreographer` reflection for frame metrics collection to avoid blocking the main thread during `Sentry.init` ([#5886](https://github.com/getsentry/sentry-java/pull/5886))
+- Defer use of reflection by `SentryFrameMetricsCollector` during `Sentry.init` ([#5886](https://github.com/getsentry/sentry-java/pull/5886))
 - Avoid waiting up to `shutdownTimeoutMillis` when closing the SDK with a pending transaction timeout or session-end task ([#5851](https://github.com/getsentry/sentry-java/pull/5851))
 - Use `RGB_565` instead of `ARGB_8888` for screenshot and replay capture bitmaps, halving per-frame memory usage ([#5821](https://github.com/getsentry/sentry-java/pull/5821))
 - Remove an unused lock from `SentryPerformanceProvider`, which was allocated on every cold start in `ContentProvider.onCreate` without ever being acquired ([#5871](https://github.com/getsentry/sentry-java/pull/5871))

From df9daab57352f916ab1d0de7411671bfaf189678 Mon Sep 17 00:00:00 2001
From: runningcode <332597+runningcode@users.noreply.github.com>
Date: Wed, 5 Aug 2026 14:30:08 +0000
Subject: [PATCH 368/391] release: 8.52.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fe246b62787..a200976b614 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.52.0
 
 ### Fixes
 
diff --git a/gradle.properties b/gradle.properties
index 5558c29164f..e1f7ecae6dc 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -16,7 +16,7 @@ android.newDsl=false
 android.experimental.lint.version=9.2.1
 
 # Release information
-versionName=8.51.0
+versionName=8.52.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 32a6f2e9a43d747f4c7e2341502610f98696772e Mon Sep 17 00:00:00 2001
From: "sentry-junior[bot]"
 <264270552+sentry-junior[bot]@users.noreply.github.com>
Date: Thu, 6 Aug 2026 12:11:00 +0200
Subject: [PATCH 369/391] fix(android): Preserve custom Throwable identities
 (#5881)

* fix(android): Preserve custom Throwable identities

Co-Authored-By: Roman Zavarnitsyn <roman.zavarnitsyn@sentry.io>

* changelog

---------

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: Roman Zavarnitsyn <roman.zavarnitsyn@sentry.io>
Co-authored-by: Markus Hintersteiner <markus.hintersteiner@sentry.io>
---
 CHANGELOG.md                           | 6 ++++++
 sentry-android-core/proguard-rules.pro | 5 +++++
 2 files changed, 11 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a200976b614..6130860ee36 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Changelog
 
+## Unreleased
+
+### Fixes
+
+- Preserve custom `Throwable` identities when R8 optimizes Android apps ([#5881](https://github.com/getsentry/sentry-java/pull/5881))
+
 ## 8.52.0
 
 ### Fixes
diff --git a/sentry-android-core/proguard-rules.pro b/sentry-android-core/proguard-rules.pro
index 4cd76f9a20d..a66e472b07c 100644
--- a/sentry-android-core/proguard-rules.pro
+++ b/sentry-android-core/proguard-rules.pro
@@ -29,6 +29,11 @@
 # https://developer.android.com/studio/build/shrink-code#decode-stack-trace
 -keepattributes LineNumberTable,SourceFile
 
+# Preserve distinct runtime identities for custom Throwables. R8 horizontal class merging can
+# otherwise merge unrelated exception classes, causing the runtime type and retraced frames to
+# disagree. Unused Throwables may still be removed, and retained Throwables may still be obfuscated.
+-keep,allowshrinking,allowobfuscation class * extends java.lang.Throwable
+
 # Keep Classnames for integrations
 -keepnames class * implements io.sentry.Integration
 

From 7d649bdd70115e92535cea71b7a74109b8e1f4e9 Mon Sep 17 00:00:00 2001
From: Alexander Tarasov <alex.tarasov@sentry.io>
Date: Thu, 6 Aug 2026 12:39:07 +0200
Subject: [PATCH 370/391] ci: Replace curl-pipe-bash with action-setup-cli
 (#5899)

Refs VULN-2261

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
---
 .github/workflows/build.yml                | 2 +-
 .github/workflows/integration-tests-ui.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 1237b5f7d40..ef9aa7cfc36 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -46,7 +46,7 @@ jobs:
         run: make preMerge
 
       - name: Install Sentry CLI
-        run: curl -sL https://sentry.io/get-cli/ | bash
+        uses: getsentry/action-setup-cli@70d7e587b84c2e78cf4d37cd33d7b74fb3729c1b # v1
 
       - name: Upload Snapshots to Sentry
         # Skip on PRs from forks, which don't have access to the upload secret
diff --git a/.github/workflows/integration-tests-ui.yml b/.github/workflows/integration-tests-ui.yml
index 815611507d1..043c4730f32 100644
--- a/.github/workflows/integration-tests-ui.yml
+++ b/.github/workflows/integration-tests-ui.yml
@@ -75,7 +75,7 @@ jobs:
 
       - name: Install Sentry CLI
         if: ${{ !cancelled() && env.SAUCE_USERNAME != null }}
-        run: curl -sL https://sentry.io/get-cli/ | bash
+        uses: getsentry/action-setup-cli@70d7e587b84c2e78cf4d37cd33d7b74fb3729c1b # v1
 
       - name: Upload Replay Snapshots to Sentry
         # Skip on PRs from forks, which don't have access to the upload secret

From 8a8d947171997a44898ad42f9e174d0f1448092f Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 6 Aug 2026 16:10:22 +0200
Subject: [PATCH 371/391] fix(core): Clear contexts on Scope.clear() (#5902)

* fix(core): Clear contexts on Scope.clear() (JAVA-683)

Scope.clear() reset every field except contexts, so anything set via
setContexts survived a clear. Contexts had no clear() method, unlike the
tags, extra, and fingerprint collections, which is why it was skipped.

Add Contexts.clear(), override it in CombinedContextsView to delegate to
the default context, and clear contexts in Scope.clear() while notifying
scope observers so persisted scopes stay in sync.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 CHANGELOG.md                                    |  1 +
 sentry/api/sentry.api                           |  2 ++
 .../java/io/sentry/CombinedContextsView.java    |  5 +++++
 sentry/src/main/java/io/sentry/Scope.java       |  5 +++++
 .../main/java/io/sentry/protocol/Contexts.java  |  4 ++++
 .../java/io/sentry/CombinedContextsViewTest.kt  | 14 ++++++++++++++
 sentry/src/test/java/io/sentry/ScopeTest.kt     | 17 +++++++++++++++++
 .../java/io/sentry/protocol/ContextsTest.kt     | 12 ++++++++++++
 8 files changed, 60 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6130860ee36..1da07233a0f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Fixes
 
+- Clear contexts when calling `Scope.clear()` ([#5902](https://github.com/getsentry/sentry-java/pull/5902))
 - Preserve custom `Throwable` identities when R8 optimizes Android apps ([#5881](https://github.com/getsentry/sentry-java/pull/5881))
 
 ## 8.52.0
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 51cffae3302..43de4164a4f 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -227,6 +227,7 @@ public final class io/sentry/CheckInStatus : java/lang/Enum {
 
 public final class io/sentry/CombinedContextsView : io/sentry/protocol/Contexts {
 	public fun <init> (Lio/sentry/protocol/Contexts;Lio/sentry/protocol/Contexts;Lio/sentry/protocol/Contexts;Lio/sentry/ScopeType;)V
+	public fun clear ()V
 	public fun containsKey (Ljava/lang/Object;)Z
 	public fun entrySet ()Ljava/util/Set;
 	public fun get (Ljava/lang/Object;)Ljava/lang/Object;
@@ -5795,6 +5796,7 @@ public class io/sentry/protocol/Contexts : io/sentry/JsonSerializable {
 	protected final field responseLock Lio/sentry/util/AutoClosableReentrantLock;
 	public fun <init> ()V
 	public fun <init> (Lio/sentry/protocol/Contexts;)V
+	public fun clear ()V
 	public fun containsKey (Ljava/lang/Object;)Z
 	public fun entrySet ()Ljava/util/Set;
 	public fun equals (Ljava/lang/Object;)Z
diff --git a/sentry/src/main/java/io/sentry/CombinedContextsView.java b/sentry/src/main/java/io/sentry/CombinedContextsView.java
index 3cb10e88b81..d9a8b14c628 100644
--- a/sentry/src/main/java/io/sentry/CombinedContextsView.java
+++ b/sentry/src/main/java/io/sentry/CombinedContextsView.java
@@ -293,6 +293,11 @@ public boolean containsKey(final @Nullable Object key) {
     return getDefaultContexts().remove(key);
   }
 
+  @Override
+  public void clear() {
+    getDefaultContexts().clear();
+  }
+
   @Override
   public @NotNull Enumeration<String> keys() {
     return mergeContexts().keys();
diff --git a/sentry/src/main/java/io/sentry/Scope.java b/sentry/src/main/java/io/sentry/Scope.java
index 195e5b5b05a..25f36cd3f59 100644
--- a/sentry/src/main/java/io/sentry/Scope.java
+++ b/sentry/src/main/java/io/sentry/Scope.java
@@ -575,10 +575,15 @@ public void clear() {
     tags.clear();
     attributes.clear();
     extra.clear();
+    contexts.clear();
     eventProcessors.clear();
     clearTransaction();
     clearAttachments();
     clearFeatureFlags();
+
+    for (final IScopeObserver observer : options.getScopeObservers()) {
+      observer.setContexts(contexts);
+    }
   }
 
   /**
diff --git a/sentry/src/main/java/io/sentry/protocol/Contexts.java b/sentry/src/main/java/io/sentry/protocol/Contexts.java
index 83a770eb0fc..f6ba635383a 100644
--- a/sentry/src/main/java/io/sentry/protocol/Contexts.java
+++ b/sentry/src/main/java/io/sentry/protocol/Contexts.java
@@ -248,6 +248,10 @@ public boolean containsKey(final @Nullable Object key) {
     return internalStorage.remove(key);
   }
 
+  public void clear() {
+    internalStorage.clear();
+  }
+
   public @NotNull Enumeration<String> keys() {
     return internalStorage.keys();
   }
diff --git a/sentry/src/test/java/io/sentry/CombinedContextsViewTest.kt b/sentry/src/test/java/io/sentry/CombinedContextsViewTest.kt
index 43ded1ad2ae..0fb7d07c0a0 100644
--- a/sentry/src/test/java/io/sentry/CombinedContextsViewTest.kt
+++ b/sentry/src/test/java/io/sentry/CombinedContextsViewTest.kt
@@ -605,6 +605,20 @@ class CombinedContextsViewTest {
     assertEquals("global", fixture.global.get("test"))
   }
 
+  @Test
+  fun `clear clears default context only`() {
+    val combined = fixture.getSut()
+    fixture.current.put("test", "current")
+    fixture.isolation.put("test", "isolation")
+    fixture.global.put("test", "global")
+
+    combined.clear()
+
+    assertEquals("current", fixture.current.get("test"))
+    assertNull(fixture.isolation.get("test"))
+    assertEquals("global", fixture.global.get("test"))
+  }
+
   @Test
   fun `set null value on context does not cause exception`() {
     val combined = fixture.getSut()
diff --git a/sentry/src/test/java/io/sentry/ScopeTest.kt b/sentry/src/test/java/io/sentry/ScopeTest.kt
index 7af4f6ccdca..be6a22516c0 100644
--- a/sentry/src/test/java/io/sentry/ScopeTest.kt
+++ b/sentry/src/test/java/io/sentry/ScopeTest.kt
@@ -292,6 +292,7 @@ class ScopeTest {
     scope.screen = "MainActivity"
     scope.setExtra("some", "extra")
     scope.setAttribute("some", "attribute")
+    scope.setContexts("some", "context")
     scope.addEventProcessor(eventProcessor())
     scope.addAttachment(Attachment("path"))
     scope.addFeatureFlag("flag", true)
@@ -308,6 +309,7 @@ class ScopeTest {
     assertEquals(0, scope.tags.size)
     assertEquals(0, scope.attributes.size)
     assertEquals(0, scope.extras.size)
+    assertTrue(scope.contexts.isEmpty)
     assertEquals(0, scope.eventProcessors.size)
     assertEquals(0, scope.attachments.size)
     assertEquals(0, scope.featureFlags!!.values.size)
@@ -886,6 +888,21 @@ class ScopeTest {
     verify(observer).setContexts(argThat { (get("test") as Obj).stuff == 3 })
   }
 
+  @Test
+  fun `Scope clear contexts sync scopes`() {
+    val observer = mock<IScopeObserver>()
+    val options = SentryOptions().apply { addScopeObserver(observer) }
+    val scope = Scope(options)
+
+    // Populate the live contexts directly so the observer is only notified by clear().
+    scope.contexts.set("test", "value")
+    assertFalse(scope.contexts.isEmpty)
+
+    scope.clear()
+    assertTrue(scope.contexts.isEmpty)
+    verify(observer).setContexts(argThat { isEmpty })
+  }
+
   @Test
   fun `Scope set propagation context sync scopes`() {
     val observer = mock<IScopeObserver>()
diff --git a/sentry/src/test/java/io/sentry/protocol/ContextsTest.kt b/sentry/src/test/java/io/sentry/protocol/ContextsTest.kt
index 0035b733b43..7a3f425e997 100644
--- a/sentry/src/test/java/io/sentry/protocol/ContextsTest.kt
+++ b/sentry/src/test/java/io/sentry/protocol/ContextsTest.kt
@@ -7,6 +7,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFalse
 import kotlin.test.assertNotNull
 import kotlin.test.assertNotSame
+import kotlin.test.assertTrue
 
 class ContextsTest {
   @Test
@@ -137,4 +138,15 @@ class ContextsTest {
 
     assertEquals(listOf("a"), contexts.keys().toList())
   }
+
+  @Test
+  fun `clear removes all entries from context`() {
+    val contexts = Contexts()
+    contexts.put("a", "1")
+    contexts.put("b", "2")
+
+    contexts.clear()
+
+    assertTrue(contexts.isEmpty)
+  }
 }

From 19a5688aa417ee5486b3561c77c9ba315eef290a Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 6 Aug 2026 16:27:24 +0200
Subject: [PATCH 372/391] feat(android): Add trace markers to
 SentryAndroid.init (#5901)

* feat(android): Add trace markers to SentryAndroid.init (JAVA-685)

Wrap SentryAndroid.init and the user OptionsConfiguration callback in
android.os.Trace sections so SDK startup cost shows up as named slices
in a Perfetto trace or a CI TraceSectionMetric.

Sections use constant names and allocate nothing when no trace is
recording. Kept intentionally minimal as the SDK's first shipped Trace
instrumentation.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* changelog

* feat(android): Keep only the SentryAndroid.init trace section (JAVA-685)

Drop the SentryAndroid.init.configure section to keep the SDK's first
shipped android.os.Trace instrumentation minimal and easy to review.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* Remove changelog entry in favor of #skip-changelog

* fix(android): Balance init trace section on lock failure (JAVA-685)

Move Trace.beginSection above the try-with-resources so it always
pairs with the endSection() in the finally. If staticLock.acquire()
threw (e.g. OOM allocating the lock), the body was skipped but the
finally still ran, popping an unrelated systrace section.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../src/main/java/io/sentry/android/core/SentryAndroid.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroid.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroid.java
index f27259fd635..ab18a5827b9 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroid.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryAndroid.java
@@ -5,6 +5,7 @@
 import android.content.Context;
 import android.os.Process;
 import android.os.SystemClock;
+import android.os.Trace;
 import io.sentry.ILogger;
 import io.sentry.IScopes;
 import io.sentry.ISentryLifecycleToken;
@@ -95,6 +96,9 @@ public static void init(
       @NotNull final Context context,
       @NotNull ILogger logger,
       @NotNull Sentry.OptionsConfiguration<SentryAndroidOptions> configuration) {
+    // Started before acquiring the lock so it stays balanced with the endSection() in the finally
+    // even if acquire() throws.
+    Trace.beginSection("SentryAndroid.init");
     try (final @NotNull ISentryLifecycleToken ignored = staticLock.acquire()) {
       Sentry.init(
           new SentryAndroidOptionsContainer(),
@@ -219,6 +223,8 @@ public static void init(
       logger.log(SentryLevel.FATAL, "Fatal error during SentryAndroid.init(...)", e);
 
       throw new RuntimeException("Failed to initialize Sentry's SDK", e);
+    } finally {
+      Trace.endSection();
     }
   }
 

From 79a3290cb189dfbda4226090be7291388acbd329 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 6 Aug 2026 16:34:10 +0200
Subject: [PATCH 373/391] chore(deps): bump the github-actions group with 2
 updates (#5898)

Bumps the github-actions group with 2 updates: [github/codeql-action/init](https://github.com/github/codeql-action) and [github/codeql-action/analyze](https://github.com/github/codeql-action).


Updates `github/codeql-action/init` from 4.37.4 to 4.37.5
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/f205ea1c3313d32999d8d6a48b4f6530d4437b38...d1ba80a13dd99fba24a470575428917156a28b43)

Updates `github/codeql-action/analyze` from 4.37.4 to 4.37.5
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/f205ea1c3313d32999d8d6a48b4f6530d4437b38...d1ba80a13dd99fba24a470575428917156a28b43)

---
updated-dependencies:
- dependency-name: github/codeql-action/init
  dependency-version: 4.37.5
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.37.5
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql-analysis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index b4ce0ce8101..93185ecec98 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@f205ea1c3313d32999d8d6a48b4f6530d4437b38 # pin@v2
+        uses: github/codeql-action/init@d1ba80a13dd99fba24a470575428917156a28b43 # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@f205ea1c3313d32999d8d6a48b4f6530d4437b38 # pin@v2
+        uses: github/codeql-action/analyze@d1ba80a13dd99fba24a470575428917156a28b43 # pin@v2

From 1664d46c82b86ce7e7e0e264d2d1f878d9da8d26 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 6 Aug 2026 17:02:53 +0200
Subject: [PATCH 374/391] test(android): Add SentryAndroid.init timing to
 macrobenchmark (JAVA-685) (#5903)

Read the SentryAndroid.init android.os.Trace section via a
TraceSectionMetric so the cold-start macrobenchmark reports SDK-init
duration on its own, separate from timeToInitialDisplay. This resolves
init-cost changes that the whole-start metric would bury in cold-start
noise.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>
---
 .../README.md                                 | 24 +++++++++++--------
 .../macrobenchmark/SentryStartupBenchmark.kt  | 18 ++++++++++----
 2 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/README.md b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/README.md
index eae36ac178f..4b89b7b6105 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/README.md
+++ b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/README.md
@@ -5,14 +5,17 @@ performance changes on a real device in a **stable, reproducible** way. Not run
 
 ## What it measures
 
-`SentryStartupBenchmark` runs a cold start and reports **`timeToInitialDisplay`**
-(`StartupTimingMetric`) per iteration — the whole app cold start, taken from framework trace
-events. No trace markers are required in the SDK or the app.
-
-The flip side of marker-free measurement: an SDK change has to be large enough (roughly tens of
-milliseconds) to show above cold-start noise. Sub-millisecond changes are not resolvable with
-`timeToInitialDisplay` alone; for those, capture a perfetto trace and inspect the relevant slices
-directly (each iteration's trace is saved under
+`SentryStartupBenchmark` runs a cold start and reports two metrics per iteration:
+
+- **`timeToInitialDisplay`** (`StartupTimingMetric`) — the whole app cold start, taken from
+  framework trace events. Because it captures the entire start, an SDK change has to be large enough
+  (roughly tens of milliseconds) to show above cold-start noise.
+- **`SentryAndroid.init`** (`TraceSectionMetric`) — the duration of the `SentryAndroid.init`
+  `android.os.Trace` section the SDK emits, which isolates SDK-init cost from the rest of the start
+  and resolves changes that `timeToInitialDisplay` would lose in the noise.
+
+For even finer detail (sub-millisecond changes, or cost inside init), capture a perfetto trace and
+inspect the relevant slices directly (each iteration's trace is saved under
 `build/outputs/connected_android_test_additional_output/`).
 
 `CompilationMode.Full()` pins ART AOT so dexopt state can't drift between runs. `StartupMode.COLD`
@@ -49,5 +52,6 @@ Results print to the console and are written to
 Macrobenchmark measures one build per run, so compare separate runs — but **interleave them**:
 running all of variant A followed by all of variant B lets thermal drift systematically penalize
 whichever variant runs second. Instead, alternate A/B rounds (build variant A, run, build variant
-B, run, repeat 2–3 times), keep each round's `*-benchmarkData.json`, and compare the
-`timeToInitialDisplay` values pooled per variant.
+B, run, repeat 2–3 times), keep each round's `*-benchmarkData.json`, and compare the values pooled
+per variant. Prefer the `SentryAndroid.init` metric for SDK-init changes — it isolates init cost, so
+it moves on changes that `timeToInitialDisplay` would bury in cold-start noise.
diff --git a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/java/io/sentry/uitest/android/macrobenchmark/SentryStartupBenchmark.kt b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/java/io/sentry/uitest/android/macrobenchmark/SentryStartupBenchmark.kt
index 24b8707ba5d..ee49fe8beff 100644
--- a/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/java/io/sentry/uitest/android/macrobenchmark/SentryStartupBenchmark.kt
+++ b/sentry-android-integration-tests/sentry-uitest-android-macrobenchmark/src/main/java/io/sentry/uitest/android/macrobenchmark/SentryStartupBenchmark.kt
@@ -1,8 +1,10 @@
 package io.sentry.uitest.android.macrobenchmark
 
 import androidx.benchmark.macro.CompilationMode
+import androidx.benchmark.macro.ExperimentalMetricApi
 import androidx.benchmark.macro.StartupMode
 import androidx.benchmark.macro.StartupTimingMetric
+import androidx.benchmark.macro.TraceSectionMetric
 import androidx.benchmark.macro.junit4.MacrobenchmarkRule
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import org.junit.Rule
@@ -13,10 +15,12 @@ import org.junit.runner.RunWith
  * Cold-start benchmark for the sentry-samples-android app, used to evaluate SDK-init changes on a
  * real device in a stable, repeatable way.
  *
- * Reports timeToInitialDisplay ([StartupTimingMetric]) per iteration. This measures the whole app
- * cold start from framework trace events, with no trace markers in the SDK or the app — which also
- * means SDK changes need to be large enough (roughly tens of milliseconds) to show above cold-start
- * noise.
+ * Reports two metrics per iteration:
+ * - timeToInitialDisplay ([StartupTimingMetric]) — the whole app cold start from framework trace
+ *   events. Because it captures the entire start, an SDK change has to be large enough (roughly
+ *   tens of milliseconds) to show above cold-start noise.
+ * - SentryAndroid.init ([TraceSectionMetric]) — the duration of the `SentryAndroid.init`
+ *   [android.os.Trace] section the SDK emits, isolating SDK-init cost from the rest of the start.
  *
  * [CompilationMode.Full] pins ART AOT compilation so dexopt state does not drift between runs.
  * Iterations are capped at 12: on an unthrottled Pixel 3, back-to-back cold starts hit thermal
@@ -24,6 +28,7 @@ import org.junit.runner.RunWith
  * it requires a connected device. To A/B an SDK change, see README.md (build the app twice, once
  * per SDK variant, in interleaved rounds).
  */
+@OptIn(ExperimentalMetricApi::class)
 @RunWith(AndroidJUnit4::class)
 class SentryStartupBenchmark {
 
@@ -33,7 +38,7 @@ class SentryStartupBenchmark {
   fun startupFullCompilation() =
     benchmarkRule.measureRepeated(
       packageName = TARGET_PACKAGE,
-      metrics = listOf(StartupTimingMetric()),
+      metrics = listOf(StartupTimingMetric(), TraceSectionMetric(INIT_TRACE_SECTION)),
       compilationMode = CompilationMode.Full(),
       startupMode = StartupMode.COLD,
       iterations = 12,
@@ -44,5 +49,8 @@ class SentryStartupBenchmark {
 
   private companion object {
     const val TARGET_PACKAGE = "io.sentry.samples.android"
+
+    // Matches the android.os.Trace section name in SentryAndroid.init.
+    const val INIT_TRACE_SECTION = "SentryAndroid.init"
   }
 }

From 994085e5e4a2bdd18ed240b488925e2bbf375623 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 7 Aug 2026 12:48:31 +0000
Subject: [PATCH 375/391] chore(deps): bump the github-actions group with 2
 updates (#5905)

Bumps the github-actions group with 2 updates: [github/codeql-action/init](https://github.com/github/codeql-action) and [github/codeql-action/analyze](https://github.com/github/codeql-action).


Updates `github/codeql-action/init` from 4.37.5 to 4.37.6
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/d1ba80a13dd99fba24a470575428917156a28b43...5595ccaf912efad79be6eef63a5619ff05969be3)

Updates `github/codeql-action/analyze` from 4.37.5 to 4.37.6
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/d1ba80a13dd99fba24a470575428917156a28b43...5595ccaf912efad79be6eef63a5619ff05969be3)

---
updated-dependencies:
- dependency-name: github/codeql-action/init
  dependency-version: 4.37.6
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
- dependency-name: github/codeql-action/analyze
  dependency-version: 4.37.6
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: github-actions
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codeql-analysis.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 93185ecec98..57e2e4a1073 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -36,7 +36,7 @@ jobs:
           cache-encryption-key: ${{ secrets.GRADLE_ENCRYPTION_KEY }}
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@d1ba80a13dd99fba24a470575428917156a28b43 # pin@v2
+        uses: github/codeql-action/init@5595ccaf912efad79be6eef63a5619ff05969be3 # pin@v2
         with:
           languages: 'java'
 
@@ -45,4 +45,4 @@ jobs:
           ./gradlew buildForCodeQL --no-build-cache
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@d1ba80a13dd99fba24a470575428917156a28b43 # pin@v2
+        uses: github/codeql-action/analyze@5595ccaf912efad79be6eef63a5619ff05969be3 # pin@v2

From 983e0f0a5f1c89118d4e82b6f928fb4e738ca97b Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 7 Aug 2026 12:53:13 +0000
Subject: [PATCH 376/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.16.2 (#5910)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 6 ++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1da07233a0f..f3ef91d1cc7 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,12 @@
 - Clear contexts when calling `Scope.clear()` ([#5902](https://github.com/getsentry/sentry-java/pull/5902))
 - Preserve custom `Throwable` identities when R8 optimizes Android apps ([#5881](https://github.com/getsentry/sentry-java/pull/5881))
 
+### Dependencies
+
+- Bump Native SDK from v0.16.1 to v0.16.2 ([#5910](https://github.com/getsentry/sentry-java/pull/5910))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0162)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.16.1...0.16.2)
+
 ## 8.52.0
 
 ### Fixes
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 498e4c0e3ee..0a47ab7e6c6 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -169,7 +169,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.16.1" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.16.2" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 69ee9eb8af552f89d05ff828bb8d71319ef81f66 Mon Sep 17 00:00:00 2001
From: "sentry-junior[bot]"
 <264270552+sentry-junior[bot]@users.noreply.github.com>
Date: Tue, 11 Aug 2026 10:26:57 +0200
Subject: [PATCH 377/391] feat(core): Make ISpan startChild SpanOptions
 overloads public (#5927)

* feat(core): Make ISpan startChild SpanOptions overloads public

Unmark the SpanOptions-based startChild overloads on ISpan so callers
can set an explicit start timestamp without using internal API.

Co-Authored-By: Roman Zavarnitsyn <roman.zavarnitsyn@sentry.io>

* changelog

Co-Authored-By: Roman Zavarnitsyn <roman.zavarnitsyn@sentry.io>

---------

Co-authored-by: sentry-junior[bot] <264270552+sentry-junior[bot]@users.noreply.github.com>
Co-authored-by: Roman Zavarnitsyn <roman.zavarnitsyn@sentry.io>
---
 CHANGELOG.md                              |  4 ++++
 sentry/src/main/java/io/sentry/ISpan.java | 17 +++++++++++++++--
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f3ef91d1cc7..eeb7138aff1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Features
+
+- Make `ISpan.startChild` overloads with `SpanOptions` public ([#5927](https://github.com/getsentry/sentry-java/pull/5927))
+
 ### Fixes
 
 - Clear contexts when calling `Scope.clear()` ([#5902](https://github.com/getsentry/sentry-java/pull/5902))
diff --git a/sentry/src/main/java/io/sentry/ISpan.java b/sentry/src/main/java/io/sentry/ISpan.java
index ee8fbe1a895..7f54b7e58a2 100644
--- a/sentry/src/main/java/io/sentry/ISpan.java
+++ b/sentry/src/main/java/io/sentry/ISpan.java
@@ -17,12 +17,25 @@ public interface ISpan {
   @NotNull
   ISpan startChild(@NotNull String operation);
 
-  @ApiStatus.Internal
+  /**
+   * Starts a child Span.
+   *
+   * @param operation - new span operation name
+   * @param description - new span description name
+   * @param spanOptions - options for the newly created span, e.g. an explicit start timestamp
+   * @return a new transaction span
+   */
   @NotNull
   ISpan startChild(
       @NotNull String operation, @Nullable String description, @NotNull SpanOptions spanOptions);
 
-  @ApiStatus.Internal
+  /**
+   * Starts a child Span.
+   *
+   * @param spanContext - the context for the newly created span
+   * @param spanOptions - options for the newly created span, e.g. an explicit start timestamp
+   * @return a new transaction span
+   */
   @NotNull
   ISpan startChild(@NotNull SpanContext spanContext, @NotNull SpanOptions spanOptions);
 

From e4bb88692cf5265ef4d47e84d507678d310b9d1e Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Tue, 11 Aug 2026 15:07:24 +0200
Subject: [PATCH 378/391] perf(android): Read cpu time via
 Process.getElapsedCpuTime (#5926)

* perf(android): Read cpu time via Process.getElapsedCpuTime (JAVA-690)

AndroidCpuCollector.collect() runs 10 times per second for the whole
duration of every transaction, and each sample read and parsed
/proc/self/stat: the file reader buffers, the intermediate strings and a
regex split of all 52 fields allocated roughly 25 kB per sample, on top
of five syscalls, to obtain four numbers.

Process.getElapsedCpuTime() is a @CriticalNative wrapper around
clock_gettime(CLOCK_PROCESS_CPUTIME_ID) and returns the same quantity
with no allocation, at millisecond rather than clock-tick resolution. It
excludes the cpu time of reaped child processes, which an app process
does not have. This also drops the Pattern.compile() that ran on the
SentryAndroid.init path whether or not performance collection started.

Measured on a Pixel 3 (Android 12): collect() drops from 33623 to 16
bytes allocated per call, the remainder being the Double boxing of the
result. The reported percentages are unchanged for 1, 4 and 8 of 8 busy
cores.

Also seed lastRealtimeNanos in setup(), so the first sample is measured
against the previous sample instead of against time since boot. Under
full load that sample reported 0.0% before and 92.9% after.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* changelog

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* ref(android): Restore the cpu collector attribution comment

The percentage calculation still follows the linked article; only the
source of the process cpu time changed. Drop the measured allocation
sizes from the comment - they belong in the commit history, not next to
code that no longer allocates.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* ref(android): Drop the stale cpu collector attribution comment

The linked article describes reading and parsing /proc/self/stat, which
this collector no longer does.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  5 ++
 .../android/core/AndroidCpuCollector.java     | 65 ++++---------------
 2 files changed, 16 insertions(+), 54 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eeb7138aff1..6588c0a78f2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,11 @@
 
 - Clear contexts when calling `Scope.clear()` ([#5902](https://github.com/getsentry/sentry-java/pull/5902))
 - Preserve custom `Throwable` identities when R8 optimizes Android apps ([#5881](https://github.com/getsentry/sentry-java/pull/5881))
+- Report the correct cpu usage for the first performance sample of a transaction, which was measured against the time since device boot ([#5926](https://github.com/getsentry/sentry-java/pull/5926))
+
+### Performance
+
+- Reduce allocations while collecting cpu usage during transactions by reading the process cpu time via `Process.getElapsedCpuTime()` instead of parsing `/proc/self/stat` (33.6kB to 16 bytes per sample on a Pixel 3) ([#5926](https://github.com/getsentry/sentry-java/pull/5926))
 
 ### Dependencies
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidCpuCollector.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidCpuCollector.java
index ea7a20deab1..cb8e148b318 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidCpuCollector.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidCpuCollector.java
@@ -1,56 +1,42 @@
 package io.sentry.android.core;
 
+import android.os.Process;
 import android.os.SystemClock;
 import android.system.Os;
 import android.system.OsConstants;
 import io.sentry.ILogger;
 import io.sentry.IPerformanceSnapshotCollector;
 import io.sentry.PerformanceCollectionData;
-import io.sentry.SentryLevel;
-import io.sentry.util.FileUtils;
 import io.sentry.util.Objects;
-import java.io.File;
-import java.io.IOException;
-import java.util.regex.Pattern;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.NotNull;
 
-// The approach to get the cpu usage info was taken from
-// https://eng.lyft.com/monitoring-cpu-performance-of-lyfts-android-applications-4e36fafffe12
-// The content of the /proc/self/stat file is specified in
-// https://man7.org/linux/man-pages/man5/proc.5.html
+// The process cpu time comes from Process.getElapsedCpuTime(), a @CriticalNative wrapper around
+// clock_gettime(CLOCK_PROCESS_CPUTIME_ID), rather than from parsing /proc/self/stat: reading and
+// parsing that file allocated on every sample, and collect() runs 10 times per second for the whole
+// duration of a transaction. It does not include the cpu time of reaped child processes, which an
+// app process doesn't have.
 @ApiStatus.Internal
 public final class AndroidCpuCollector implements IPerformanceSnapshotCollector {
 
+  private static final long NANOSECONDS_PER_MILLISECOND = 1_000_000;
+
   private long lastRealtimeNanos = 0;
   private long lastCpuNanos = 0;
 
-  /** Number of clock ticks per second. */
-  private long clockSpeedHz = 1;
-
   private long numCores = 1;
-  private final long NANOSECOND_PER_SECOND = 1_000_000_000;
-
-  /** Number of nanoseconds per clock tick. */
-  private double nanosecondsPerClockTick = NANOSECOND_PER_SECOND / (double) clockSpeedHz;
 
-  /** File containing stats about this process. */
-  private final @NotNull File selfStat = new File("/proc/self/stat");
-
-  private final @NotNull ILogger logger;
   private boolean isEnabled = false;
-  private final @NotNull Pattern newLinePattern = Pattern.compile("[\n\t\r ]");
 
   public AndroidCpuCollector(final @NotNull ILogger logger) {
-    this.logger = Objects.requireNonNull(logger, "Logger is required.");
+    Objects.requireNonNull(logger, "Logger is required.");
   }
 
   @Override
   public void setup() {
     isEnabled = true;
-    clockSpeedHz = Os.sysconf(OsConstants._SC_CLK_TCK);
     numCores = Os.sysconf(OsConstants._SC_NPROCESSORS_CONF);
-    nanosecondsPerClockTick = NANOSECOND_PER_SECOND / (double) clockSpeedHz;
+    lastRealtimeNanos = SystemClock.elapsedRealtimeNanos();
     lastCpuNanos = readTotalCpuNanos();
   }
 
@@ -74,36 +60,7 @@ public void collect(final @NotNull PerformanceCollectionData performanceCollecti
         (cpuUsagePercentage / (double) numCores) * 100.0);
   }
 
-  /** Read the /proc/self/stat file and parses the result. */
   private long readTotalCpuNanos() {
-    String stat = null;
-    try {
-      stat = FileUtils.readText(selfStat);
-    } catch (IOException e) {
-      // If an error occurs when reading the file, we avoid reading it again until the setup method
-      // is called again
-      isEnabled = false;
-      logger.log(
-          SentryLevel.WARNING, "Unable to read /proc/self/stat file. Disabling cpu collection.", e);
-    }
-    if (stat != null) {
-      stat = stat.trim();
-      String[] stats = newLinePattern.split(stat);
-      try {
-        // Amount of clock ticks this process has been scheduled in user mode
-        long uTime = Long.parseLong(stats[13]);
-        // Amount of clock ticks this process has been scheduled in kernel mode
-        long sTime = Long.parseLong(stats[14]);
-        // Amount of clock ticks this process' waited-for children has been scheduled in user mode
-        long cuTime = Long.parseLong(stats[15]);
-        // Amount of clock ticks this process' waited-for children has been scheduled in kernel mode
-        long csTime = Long.parseLong(stats[16]);
-        return (long) ((uTime + sTime + cuTime + csTime) * nanosecondsPerClockTick);
-      } catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
-        logger.log(SentryLevel.ERROR, "Error parsing /proc/self/stat file.", e);
-        return 0;
-      }
-    }
-    return 0;
+    return Process.getElapsedCpuTime() * NANOSECONDS_PER_MILLISECOND;
   }
 }

From b79be83661e5561e964d789f988470b02d734c26 Mon Sep 17 00:00:00 2001
From: Roman Zavarnitsyn <rom4ek93@gmail.com>
Date: Wed, 12 Aug 2026 00:20:45 +0200
Subject: [PATCH 379/391] fix(replay): Don't let a wedged video encoder freeze
 the app (#5842)

* fix(replay): Don't let a wedged video encoder freeze the app

Some hardware encoders never emit BUFFER_FLAG_END_OF_STREAM after
signalEndOfInputStream(), so SimpleVideoEncoder.drainCodec() spun forever
while holding encoderLock. ReplayCache.close() then blocked on that lock,
and since it runs inline under ReplayIntegration's lifecycleLock, the main
thread froze until the system killed the process.

Two bounds, both needed: the drain loop now gives up after 10 consecutive
no-progress iterations (~1s), and close() only waits 2s for the encoder
lock before skipping the release. The loop bound alone isn't enough --
a native dequeueOutputBuffer call can itself never return, since
ALooper::awaitResponse has no deadline of its own.

Adds AutoClosableReentrantLock.tryAcquire(timeout, unit) for the latter.

Fixes https://github.com/getsentry/sentry-dart/issues/3556

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(replay): Log the encoder give-up at WARNING

It's an abnormal condition that drops frames, and it fires at most once
per segment, so it's worth surfacing without debug logging enabled.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* fix(replay): Address review comments on encoder ANR fix

Move isClosed.set(true) into a finally block so it runs even on unchecked
exceptions. Add a released flag to ReplayShadowMediaCodec and assert that
close() releases the encoder when the lock is available, and skips it when
timed out.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix(replay): Rename misleading test to match what it actually exercises

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  2 +
 sentry-android-replay/build.gradle.kts        |  1 +
 .../io/sentry/android/replay/ReplayCache.kt   | 34 ++++++-
 .../replay/video/SimpleVideoEncoder.kt        | 32 ++++++-
 .../sentry/android/replay/ReplayCacheTest.kt  | 92 +++++++++++++++++++
 .../replay/util/ReplayShadowMediaCodec.kt     | 28 ++++++
 sentry/api/sentry.api                         |  1 +
 .../util/AutoClosableReentrantLock.java       | 14 +++
 .../util/AutoClosableReentrantLockTest.kt     | 50 ++++++++++
 9 files changed, 248 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6588c0a78f2..29d29a751b9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,8 @@
 - Clear contexts when calling `Scope.clear()` ([#5902](https://github.com/getsentry/sentry-java/pull/5902))
 - Preserve custom `Throwable` identities when R8 optimizes Android apps ([#5881](https://github.com/getsentry/sentry-java/pull/5881))
 - Report the correct cpu usage for the first performance sample of a transaction, which was measured against the time since device boot ([#5926](https://github.com/getsentry/sentry-java/pull/5926))
+- Prevent an ANR when the Session Replay video encoder gets stuck ([#5842](https://github.com/getsentry/sentry-java/pull/5842))
+  - Some hardware encoders never signal end-of-stream, which made the replay worker spin forever while holding the encoder lock. The app's lifecycle callbacks then blocked on that lock and the app froze until the system killed it. The encoder now gives up instead of spinning, and closing the replay cache no longer waits indefinitely for a wedged encoder.
 
 ### Performance
 
diff --git a/sentry-android-replay/build.gradle.kts b/sentry-android-replay/build.gradle.kts
index 45838cb1e1b..6d03ba771b0 100644
--- a/sentry-android-replay/build.gradle.kts
+++ b/sentry-android-replay/build.gradle.kts
@@ -83,6 +83,7 @@ dependencies {
   testImplementation(libs.androidx.test.ext.junit)
   testImplementation(libs.androidx.test.runner)
   testImplementation(libs.awaitility.kotlin)
+  testImplementation(libs.google.truth)
   testImplementation(libs.mockito.kotlin)
   testImplementation(libs.mockito.inline)
   testImplementation(libs.androidx.compose.ui)
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
index 55891fea1a7..92d4a0c4018 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayCache.kt
@@ -22,6 +22,7 @@ import java.io.File
 import java.io.StringReader
 import java.util.Date
 import java.util.LinkedList
+import java.util.concurrent.TimeUnit.MILLISECONDS
 import java.util.concurrent.atomic.AtomicBoolean
 
 /**
@@ -280,11 +281,29 @@ public class ReplayCache(private val options: SentryOptions, private val replayI
   }
 
   override fun close() {
-    encoderLock.acquire().use {
-      encoder?.release()
-      encoder = null
+    // close() is called inline from the lifecycle path (ReplayIntegration.stop/close), which holds
+    // its own lock, so blocking here can freeze the main thread. If the encoder is wedged in a
+    // native MediaCodec call we'd never get the lock, so we give up instead: the already-dead codec
+    // is not released (leaking a native handle), which beats an ANR.
+    try {
+      val token = encoderLock.tryAcquire(ENCODER_RELEASE_TIMEOUT_MS, MILLISECONDS)
+      if (token == null) {
+        options.logger.log(
+          WARNING,
+          "Timed out waiting for the video encoder, skipping its release to not block the caller",
+        )
+      } else {
+        token.use {
+          encoder?.release()
+          encoder = null
+        }
+      }
+    } catch (e: InterruptedException) {
+      Thread.currentThread().interrupt()
+    } finally {
+      // has to happen on all paths, callers rely on it to stop persisting segment values
+      isClosed.set(true)
     }
-    isClosed.set(true)
   }
 
   // TODO: it's awful, choose a better serialization format
@@ -314,6 +333,13 @@ public class ReplayCache(private val options: SentryOptions, private val replayI
   }
 
   internal companion object {
+    /**
+     * How long [close] waits for the video encoder to become available. Below Android's ~5s ANR
+     * budget, and above the encoder's own bail-out (see MAX_EOS_STALL_ITERATIONS), so an encoder
+     * that's merely slow is still awaited rather than abandoned.
+     */
+    private const val ENCODER_RELEASE_TIMEOUT_MS = 2000L
+
     internal const val ONGOING_SEGMENT = ".ongoing_segment"
 
     internal const val SEGMENT_KEY_HEIGHT = "config.height"
diff --git a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
index d0cafd9f1a9..dd9af1c24d6 100644
--- a/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
+++ b/sentry-android-replay/src/main/java/io/sentry/android/replay/video/SimpleVideoEncoder.kt
@@ -37,6 +37,7 @@ import android.media.MediaFormat
 import android.os.Build
 import android.view.Surface
 import io.sentry.SentryLevel.DEBUG
+import io.sentry.SentryLevel.WARNING
 import io.sentry.SentryOptions
 import io.sentry.android.replay.util.SystemProperties
 import java.io.File
@@ -45,6 +46,16 @@ import kotlin.LazyThreadSafetyMode.NONE
 
 private const val TIMEOUT_USEC = 100_000L
 
+/**
+ * How many consecutive [MediaCodec.dequeueOutputBuffer] calls may come back without producing
+ * anything before we give up on the encoder. At [TIMEOUT_USEC] per call that's ~1s.
+ *
+ * Some hardware encoders never emit [MediaCodec.BUFFER_FLAG_END_OF_STREAM] after
+ * [MediaCodec.signalEndOfInputStream], which used to spin the drain loop forever while holding the
+ * encoder lock, wedging the whole replay pipeline (and with it the app's lifecycle callbacks).
+ */
+private const val MAX_EOS_STALL_ITERATIONS = 10
+
 @SuppressLint("UseRequiresApi")
 @TargetApi(26)
 internal class SimpleVideoEncoder(
@@ -214,19 +225,26 @@ internal class SimpleVideoEncoder(
       mediaCodec.signalEndOfInputStream()
     }
     var encoderOutputBuffers: Array<ByteBuffer?>? = mediaCodec.outputBuffers
+    // counts consecutive iterations that made no progress, so a codec that never signals EOS can't
+    // spin us forever, see MAX_EOS_STALL_ITERATIONS
+    var stalledIterations = 0
     while (true) {
       val encoderStatus: Int = mediaCodec.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC)
       if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
         // no output available yet
         if (!endOfStream) {
           break // out of while
-        } else if (options.sessionReplay.isDebug) {
+        }
+        stalledIterations++
+        if (options.sessionReplay.isDebug) {
           options.logger.log(DEBUG, "[Encoder]: no output available, spinning to await EOS")
         }
       } else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
+        stalledIterations = 0
         // not expected for an encoder
         encoderOutputBuffers = mediaCodec.outputBuffers
       } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
+        stalledIterations = 0
         // should happen before receiving buffers, and should only happen once
         if (frameMuxer.isStarted()) {
           throw RuntimeException("format changed twice")
@@ -245,8 +263,10 @@ internal class SimpleVideoEncoder(
             "[Encoder]: unexpected result from encoder.dequeueOutputBuffer: $encoderStatus",
           )
         }
-        // let's ignore it
+        // let's ignore it, but still count it as no progress so we can't loop on it forever
+        stalledIterations++
       } else {
+        stalledIterations = 0
         val encodedData =
           encoderOutputBuffers?.get(encoderStatus)
             ?: throw RuntimeException("encoderOutputBuffer $encoderStatus was null")
@@ -279,6 +299,14 @@ internal class SimpleVideoEncoder(
           break // out of while
         }
       }
+
+      if (stalledIterations >= MAX_EOS_STALL_ITERATIONS) {
+        options.logger.log(
+          WARNING,
+          "[Encoder]: encoder made no progress for $stalledIterations iterations, dropping the remaining frames",
+        )
+        break // out of while
+      }
     }
   }
 
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt
index 23e8d60044f..96e5a926af4 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/ReplayCacheTest.kt
@@ -4,6 +4,8 @@ import android.graphics.Bitmap
 import android.graphics.Bitmap.CompressFormat.JPEG
 import android.graphics.Bitmap.Config.ARGB_8888
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import com.google.common.truth.Truth.assertWithMessage
 import io.sentry.DateUtils
 import io.sentry.SentryOptions
 import io.sentry.SentryReplayEvent.ReplayType
@@ -24,7 +26,9 @@ import io.sentry.rrweb.RRWebInteractionEvent.InteractionType.TouchEnd
 import io.sentry.rrweb.RRWebInteractionEvent.InteractionType.TouchStart
 import java.io.File
 import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit.SECONDS
 import java.util.concurrent.atomic.AtomicReference
+import kotlin.concurrent.thread
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -59,6 +63,10 @@ class ReplayCacheTest {
   fun `set up`() {
     ReplayShadowMediaCodec.framesToEncode = 5
     ReplayShadowMediaCodec.throwOnStart = false
+    ReplayShadowMediaCodec.neverSignalEos = false
+    ReplayShadowMediaCodec.blockOnDequeue = null
+    ReplayShadowMediaCodec.blockedOnDequeue = CountDownLatch(1)
+    ReplayShadowMediaCodec.released = false
     ShadowBitmapFactory.setAllowInvalidImageData(true)
   }
 
@@ -654,4 +662,88 @@ class ReplayCacheTest {
     // No crash is success
     assertNull(error.get())
   }
+
+  @Test
+  fun `createVideoOf returns when the encoder never signals end of stream`() {
+    ReplayShadowMediaCodec.neverSignalEos = true
+    val replayCache = fixture.getSut(tmpDir)
+
+    val bitmap = Bitmap.createBitmap(1, 1, ARGB_8888)
+    replayCache.addFrame(bitmap, 1)
+
+    val done = CountDownLatch(1)
+    val error = AtomicReference<Throwable?>()
+    val encoder =
+      thread(isDaemon = true) {
+        try {
+          replayCache.createVideoOf(1000L, 0L, 0, 100, 200, 1, 20_000)
+        } catch (t: Throwable) {
+          error.set(t)
+        } finally {
+          done.countDown()
+        }
+      }
+
+    assertWithMessage("createVideoOf did not return, the drain loop is spinning")
+      .that(done.await(30, SECONDS))
+      .isTrue()
+    encoder.join(SECONDS.toMillis(10))
+    assertThat(error.get()).isNull()
+  }
+
+  @Test
+  fun `close does not block when the encoder is wedged, and still marks the cache closed`() {
+    val wedge = CountDownLatch(1)
+    ReplayShadowMediaCodec.blockOnDequeue = wedge
+    val replayCache = fixture.getSut(tmpDir)
+
+    val bitmap = Bitmap.createBitmap(1, 1, ARGB_8888)
+    replayCache.addFrame(bitmap, 1)
+
+    // parks inside MediaCodec while holding the encoder lock
+    val encoder =
+      thread(isDaemon = true) { replayCache.createVideoOf(1000L, 0L, 0, 100, 200, 1, 20_000) }
+    try {
+      assertWithMessage("the encoder never reached dequeueOutputBuffer")
+        .that(ReplayShadowMediaCodec.blockedOnDequeue.await(30, SECONDS))
+        .isTrue()
+
+      // on a separate thread so a regression fails the test instead of hanging the run
+      val closed = CountDownLatch(1)
+      thread(isDaemon = true) {
+        replayCache.close()
+        closed.countDown()
+      }
+      assertWithMessage("close() blocked on the wedged encoder")
+        .that(closed.await(30, SECONDS))
+        .isTrue()
+
+      // giving up on the lock still counts as closed, otherwise we'd keep persisting segments
+      replayCache.persistSegmentValues(SEGMENT_KEY_ID, "0")
+      assertThat(File(replayCache.replayCacheDir, ONGOING_SEGMENT).exists()).isFalse()
+
+      assertWithMessage("encoder should not be released when the lock times out")
+        .that(ReplayShadowMediaCodec.released)
+        .isFalse()
+    } finally {
+      wedge.countDown()
+      encoder.join(SECONDS.toMillis(10))
+    }
+  }
+
+  @Test
+  fun `createVideoOf releases the encoder even when EOS is never signalled`() {
+    ReplayShadowMediaCodec.neverSignalEos = true
+    val replayCache = fixture.getSut(tmpDir)
+
+    val bitmap = Bitmap.createBitmap(1, 1, ARGB_8888)
+    replayCache.addFrame(bitmap, 1)
+
+    // the stall bound breaks the drain loop, but release() must still be called
+    replayCache.createVideoOf(1000L, 0L, 0, 100, 200, 1, 20_000)
+
+    assertWithMessage("encoder should be released even when EOS was never signalled")
+      .that(ReplayShadowMediaCodec.released)
+      .isTrue()
+  }
 }
diff --git a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ReplayShadowMediaCodec.kt b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ReplayShadowMediaCodec.kt
index 60ccb157747..e0e13076ea0 100644
--- a/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ReplayShadowMediaCodec.kt
+++ b/sentry-android-replay/src/test/java/io/sentry/android/replay/util/ReplayShadowMediaCodec.kt
@@ -3,6 +3,7 @@ package io.sentry.android.replay.util
 import android.media.MediaCodec
 import android.media.MediaCodec.BufferInfo
 import java.nio.ByteBuffer
+import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit.MICROSECONDS
 import java.util.concurrent.TimeUnit.MILLISECONDS
 import java.util.concurrent.atomic.AtomicBoolean
@@ -16,10 +17,30 @@ class ReplayShadowMediaCodec : ShadowMediaCodec() {
     var frameRate = 1
     var framesToEncode = 5
     var throwOnStart = false
+
+    /** Simulates an encoder that never emits [MediaCodec.BUFFER_FLAG_END_OF_STREAM]. */
+    var neverSignalEos = false
+
+    /**
+     * When set, [dequeueOutputBuffer] awaits this latch, simulating a native call that never
+     * returns. [blockedOnDequeue] is counted down right before, so tests can wait until the codec
+     * is actually stuck.
+     */
+    var blockOnDequeue: CountDownLatch? = null
+
+    var blockedOnDequeue = CountDownLatch(1)
+
+    /** Set to `true` when [release] is called. */
+    var released = false
   }
 
   private val encoded = AtomicBoolean(false)
 
+  @Implementation
+  fun release() {
+    released = true
+  }
+
   @Implementation
   fun start() {
     if (throwOnStart) {
@@ -30,6 +51,9 @@ class ReplayShadowMediaCodec : ShadowMediaCodec() {
 
   @Implementation
   fun signalEndOfInputStream() {
+    if (neverSignalEos) {
+      return
+    }
     encodeFrame(framesToEncode, frameRate, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
   }
 
@@ -37,6 +61,10 @@ class ReplayShadowMediaCodec : ShadowMediaCodec() {
 
   @Implementation
   fun dequeueOutputBuffer(info: BufferInfo, timeoutUs: Long): Int {
+    blockOnDequeue?.let {
+      blockedOnDequeue.countDown()
+      it.await()
+    }
     val encoderStatus = super.native_dequeueOutputBuffer(info, timeoutUs)
     super.validateOutputByteBuffer(getOutputBuffers(), encoderStatus, info)
     if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER && !encoded.getAndSet(true)) {
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 43de4164a4f..3f8176de977 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -7641,6 +7641,7 @@ public final class io/sentry/util/AutoClosableReentrantLock : io/sentry/ISentryL
 	public fun <init> ()V
 	public fun acquire ()Lio/sentry/ISentryLifecycleToken;
 	public fun close ()V
+	public fun tryAcquire (JLjava/util/concurrent/TimeUnit;)Lio/sentry/ISentryLifecycleToken;
 }
 
 public final class io/sentry/util/CheckInUtils {
diff --git a/sentry/src/main/java/io/sentry/util/AutoClosableReentrantLock.java b/sentry/src/main/java/io/sentry/util/AutoClosableReentrantLock.java
index cf53d860e08..617c1a5b4fa 100644
--- a/sentry/src/main/java/io/sentry/util/AutoClosableReentrantLock.java
+++ b/sentry/src/main/java/io/sentry/util/AutoClosableReentrantLock.java
@@ -1,6 +1,7 @@
 package io.sentry.util;
 
 import io.sentry.ISentryLifecycleToken;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import java.util.concurrent.locks.ReentrantLock;
 import org.jetbrains.annotations.ApiStatus;
@@ -38,6 +39,19 @@ public final class AutoClosableReentrantLock implements ISentryLifecycleToken {
     return this;
   }
 
+  /**
+   * Like {@link #acquire()}, but gives up after {@code timeout}. Use it when blocking forever would
+   * be worse than not doing the work at all, e.g. on a path that can run on the main thread.
+   *
+   * @return the token (this instance) if the lock was acquired, or {@code null} if it wasn't. A
+   *     {@code null} return means the lock is <b>not</b> held, so {@link #close()} must not be
+   *     called for it.
+   */
+  public @Nullable ISentryLifecycleToken tryAcquire(
+      final long timeout, final @NotNull TimeUnit unit) throws InterruptedException {
+    return getOrCreateLock().tryLock(timeout, unit) ? this : null;
+  }
+
   @Override
   public void close() {
     Objects.requireNonNull(lock, "close() called before acquire()").unlock();
diff --git a/sentry/src/test/java/io/sentry/util/AutoClosableReentrantLockTest.kt b/sentry/src/test/java/io/sentry/util/AutoClosableReentrantLockTest.kt
index 943a2c2bf70..b46cfbaea50 100644
--- a/sentry/src/test/java/io/sentry/util/AutoClosableReentrantLockTest.kt
+++ b/sentry/src/test/java/io/sentry/util/AutoClosableReentrantLockTest.kt
@@ -1,5 +1,6 @@
 package io.sentry.util
 
+import com.google.common.truth.Truth.assertThat
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
@@ -41,6 +42,55 @@ class AutoClosableReentrantLockTest {
     assertFalse(lock.isLocked)
   }
 
+  @Test
+  fun `tryAcquire returns the lock itself as the token when free`() {
+    val lock = AutoClosableReentrantLock()
+    val token = lock.tryAcquire(1, TimeUnit.SECONDS)
+    assertThat(token).isSameInstanceAs(lock)
+    token!!.use { assertThat(lock.isLocked).isTrue() }
+    assertThat(lock.isLocked).isFalse()
+  }
+
+  @Test
+  fun `tryAcquire does not allocate the underlying lock until first use`() {
+    val lock = AutoClosableReentrantLock()
+    assertThat(lock.isLockAllocated).isFalse()
+    lock.tryAcquire(1, TimeUnit.SECONDS)!!.use {}
+    assertThat(lock.isLockAllocated).isTrue()
+  }
+
+  @Test
+  fun `tryAcquire returns null when another thread holds the lock past the timeout`() {
+    val lock = AutoClosableReentrantLock()
+    val acquired = CountDownLatch(1)
+    val release = CountDownLatch(1)
+    val holder = Thread {
+      lock.acquire().use {
+        acquired.countDown()
+        release.await()
+      }
+    }
+    holder.start()
+    try {
+      assertThat(acquired.await(10, TimeUnit.SECONDS)).isTrue()
+      assertThat(lock.tryAcquire(10, TimeUnit.MILLISECONDS)).isNull()
+    } finally {
+      release.countDown()
+      holder.join(TimeUnit.SECONDS.toMillis(10))
+    }
+    assertThat(lock.isLocked).isFalse()
+  }
+
+  @Test
+  fun `tryAcquire is reentrant from the same thread`() {
+    val lock = AutoClosableReentrantLock()
+    lock.acquire().use {
+      lock.tryAcquire(0, TimeUnit.MILLISECONDS)!!.use { assertThat(lock.isLocked).isTrue() }
+      assertThat(lock.isLocked).isTrue()
+    }
+    assertThat(lock.isLocked).isFalse()
+  }
+
   @Test
   fun `mutually excludes concurrent threads`() {
     val lock = AutoClosableReentrantLock()

From 846c4dc939b31fd855f27363b5db4e7644d8e08d Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 12 Aug 2026 10:24:30 +0200
Subject: [PATCH 380/391] perf(core): Read the clock once per performance
 collection round (#5934)

* perf(core): Read the clock once per performance collection round

While a transaction is running, performance data is collected every
100ms. CompositeData.addDataAndCheckTimeout read the clock to check for
the 30 second collection timeout once per in-flight transaction,
allocating a SentryNanotimeDate each time, even though the enclosing
timer task had just read it for the sample it was distributing.

Pass that reading in, so a collection round reads the clock once instead
of once per transaction.

* changelog
---
 CHANGELOG.md                                             | 1 +
 .../io/sentry/DefaultCompositePerformanceCollector.java  | 9 ++++++---
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 29d29a751b9..96504dc211f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,7 @@
 
 ### Performance
 
+- Read the clock once per performance collection round instead of once per in-flight transaction ([#5934](https://github.com/getsentry/sentry-java/pull/5934))
 - Reduce allocations while collecting cpu usage during transactions by reading the process cpu time via `Process.getElapsedCpuTime()` instead of parsing `/proc/self/stat` (33.6kB to 16 bytes per sample on a Pixel 3) ([#5926](https://github.com/getsentry/sentry-java/pull/5926))
 
 ### Dependencies
diff --git a/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java b/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java
index 22b8bb839b6..2b5a386300b 100644
--- a/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java
+++ b/sentry/src/main/java/io/sentry/DefaultCompositePerformanceCollector.java
@@ -124,7 +124,7 @@ public void run() {
                 // Add the enriched tempData to all transactions/profiles/objects that collect data.
                 // Then Check if that object timed out.
                 for (CompositeData data : compositeDataMap.values()) {
-                  if (data.addDataAndCheckTimeout(tempData)) {
+                  if (data.addDataAndCheckTimeout(tempData, tempData.getNanoTimestamp())) {
                     // timed out
                     if (data.transaction != null) {
                       timedOutTransactions.add(data.transaction);
@@ -224,16 +224,19 @@ private CompositeData(final @Nullable ITransaction transaction) {
      * Adds the data to the internal list of PerformanceCollectionData. Then it checks if data
      * collection timed out (for transactions only).
      *
+     * @param nowNanos the timestamp of the current collection, passed in so a single clock reading
+     *     is shared by every transaction in this collection round.
      * @return true if data collection timed out (for transactions only).
      */
-    boolean addDataAndCheckTimeout(final @NotNull PerformanceCollectionData data) {
+    boolean addDataAndCheckTimeout(
+        final @NotNull PerformanceCollectionData data, final long nowNanos) {
       // stop() hands dataList out while this timer thread may still be writing to it, so consumers
       // synchronize on the list while iterating. We must hold the same monitor here.
       synchronized (dataList) {
         dataList.add(data);
       }
       return transaction != null
-          && options.getDateProvider().now().nanoTimestamp()
+          && nowNanos
               > startTimestamp
                   + TimeUnit.MILLISECONDS.toNanos(TRANSACTION_COLLECTION_TIMEOUT_MILLIS);
     }

From 4b05f9057609d82d3aa9b6280a5e3ffba0ca1396 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 12 Aug 2026 10:25:29 +0200
Subject: [PATCH 381/391] docs(agents): Remove duplicated agent rule files
 (#5930)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* docs(agents): Remove duplicated agent rule files

coding.mdc was almost entirely a subset of AGENTS.md: the contributing
guidelines, coding rules, useful resources, and key commands sections were
near-verbatim copies. overview_dev.mdc re-described every rule three times
(once per rule bullet list, once in a keyword table) even though each rule
file already carries the same information in its frontmatter description,
and it pointed agents at fetch_rules, a Cursor-only tool.

Reduce coding.mdc to a pointer, delete overview_dev.mdc, and move the rule
index into AGENTS.md as a single table. Agents now read one file to get
started instead of three.

* docs(agents): Restore mandatory-reading language in CLAUDE.md

The dedupe commit softened the "STOP — Required Reading" block into a plain
descriptive sentence. In practice an agent then treats AGENTS.md as optional
background and answers questions without ever loading it, which is exactly
what the original wording was there to prevent.

Restore the imperative framing for AGENTS.md only. The old block also listed
coding.mdc and overview_dev.mdc as required reading; those are gone, and the
per-area rule files stay opt-in via the index table in AGENTS.md.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* docs(agents): Restore mandatory-reading language in coding.mdc

coding.mdc is alwaysApply: true, making it Cursor's auto-injected entry point —
the same role CLAUDE.md plays for Claude Code. Leaving it descriptive while
CLAUDE.md is imperative means only one of the two agents is actually told to
load AGENTS.md before doing anything.

Phrased tool-neutrally rather than naming the Read tool, since Cursor's
equivalent is read_file.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* docs(agents): Remove redundant coding.mdc pointer file

Cursor reads a root AGENTS.md automatically, so a .cursor/rules entry
whose only content is 'go read AGENTS.md' instructs Cursor to load a
file it has already merged into context. The domain-specific rules in
.cursor/rules/ are unaffected — they are alwaysApply: false and are
fetched on demand via the index table in AGENTS.md.

CLAUDE.md stays: Claude Code does not read AGENTS.md natively.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .cursor/rules/coding.mdc       |  53 -------------
 .cursor/rules/overview_dev.mdc | 133 ---------------------------------
 AGENTS.md                      |  33 +++++---
 CLAUDE.md                      |   7 +-
 4 files changed, 29 insertions(+), 197 deletions(-)
 delete mode 100644 .cursor/rules/coding.mdc
 delete mode 100644 .cursor/rules/overview_dev.mdc

diff --git a/.cursor/rules/coding.mdc b/.cursor/rules/coding.mdc
deleted file mode 100644
index 70ac39e43a2..00000000000
--- a/.cursor/rules/coding.mdc
+++ /dev/null
@@ -1,53 +0,0 @@
----
-alwaysApply: true
-description: Cursor Coding Rules
----
-
-# Contributing Rules for Agents
-
-## Overview
-
-sentry-java is the Java and Android SDK for Sentry. This repository contains the source code and examples for SDK usage.
-
-## Tech Stack
-
-- **Language**: Java and Kotlin
-- **Build Framework**: Gradle
-
-## Key Commands
-
-```bash
-# Format code and regenerate .api files
-./gradlew spotlessApply apiDump
-
-# Run all tests and linter
-./gradlew check
-
-# Run unit tests for a specific file
-./gradlew ':<module>:testReleaseUnitTest' --tests="*<file name>*" --info
-```
-
-## Contributing Guidelines
-
-1. Follow existing code style and language
-2. Do not modify the API files (e.g. sentry.api) manually, instead run `./gradlew apiDump` to regenerate them
-3. Write comprehensive tests. For assertions in new unit tests, prefer Google Truth (`com.google.common.truth.Truth.assertThat`) over `kotlin.test`/JUnit assertions; keep `kotlin.test` for test structure like `@Test` and `assertFailsWith`. Add `testImplementation(libs.google.truth)` to a module's `build.gradle.kts` if it isn't already present.
-4. New features should always be opt-in by default, extend `SentryOptions` or similar Option classes with getters and setters to enable/disable a new feature
-5. Consider backwards compatibility
-
-## Coding rules
-
-1. First think through the problem, read the codebase for relevant files, and propose a plan
-2. Before you begin working, check in with me and I will verify the plan
-3. Then, begin working on the todo items, marking them as complete as you go
-4. Please do not describe every step of the way and just give me a high level explanation of what changes you made
-5. Make every task and code change you do as simple as possible. We want to avoid making any massive or complex changes. Every change should impact as little code as possible. Everything is about simplicity.
-6. Once you're done, format the code and regenerate the .api files using the following command `./gradlew spotlessApply apiDump`
-7. As a last step, git stage the relevant files and propose (but not execute) a single git commit command (e.g. `git commit -m "<git commit message>"`)
-
-
-## Useful Resources
-
-- Main SDK documentation: https://develop.sentry.dev/sdk/overview/
-- Internal contributing guide: https://docs.sentry.io/internal/contributing/
-- Git commit messages conventions: https://develop.sentry.dev/engineering-practices/commit-messages/
diff --git a/.cursor/rules/overview_dev.mdc b/.cursor/rules/overview_dev.mdc
deleted file mode 100644
index b837be34add..00000000000
--- a/.cursor/rules/overview_dev.mdc
+++ /dev/null
@@ -1,133 +0,0 @@
----
-alwaysApply: true
-description: Sentry Java SDK - Development Rules Overview
----
-
-# Sentry Java SDK Development Rules
-
-## Always Applied Rules
-
-These rules are automatically included in every conversation:
-- **coding.mdc**: General contributing guidelines, build commands, and workflow rules
-
-## Domain-Specific Rules (Fetch Only When Needed)
-
-Use the `fetch_rules` tool to include these rules when working on specific areas:
-
-### Core SDK Functionality
-- **`api`**: Use when working with:
-  - Adding or modifying public API surface
-  - Binary compatibility, `.api` files, `apiDump`
-  - Understanding which classes to modify for new API (interfaces, implementations, no-ops, adapters)
-  - `IScope`, `IScopes`, `Sentry` static API
-  - Attributes, logging API, protocol classes
-
-- **`options`**: Use when working with:
-  - Adding or modifying SDK options (`SentryOptions`, namespaced options)
-  - External options (`ExternalOptions`, `sentry.properties`, environment variables)
-  - Android manifest metadata (`ManifestMetadataReader`)
-  - Spring Boot properties (`SentryProperties`)
-
-- **`scopes`**: Use when working with:
-  - Hub/Scope management, forking, or lifecycle
-  - `Sentry.getCurrentScopes()`, `pushScope()`, `withScope()`
-  - `ScopeType` (GLOBAL, ISOLATION, CURRENT)
-  - Thread-local storage, scope bleeding issues
-  - Migration from Hub API (v7 → v8)
-
-- **`deduplication`**: Use when working with:
-  - Duplicate event detection/prevention
-  - `DuplicateEventDetectionEventProcessor`
-  - `enableDeduplication` option
-
-- **`offline`**: Use when working with:
-  - Caching, envelope storage/retrieval
-  - Network failure handling, retry logic
-  - `AsyncHttpTransport`, `EnvelopeCache`
-  - Rate limiting, cache rotation
-  - Android vs JVM caching differences
-
-- **`feature_flags`**: Use when working with:
-  - Feature flag tracking and evaluation
-  - `addFeatureFlag()`, `getFeatureFlags()` methods
-  - `FeatureFlagBuffer`, `SpanFeatureFlagBuffer`, `FeatureFlag` protocol
-  - `maxFeatureFlags` option and buffer management
-  - Feature flag merging across scope types
-  - Scope-based vs span-based feature flag APIs
-  - Scope-based API: `Sentry`, `IScopes`, `IScope` APIs
-  - Span-based API: `ISpan`, `ITransaction` APIs
-  - Integrations: LaunchDarkly (Android/JVM), OpenFeature (JVM)
-
-- **`metrics`**: Use when working with:
-  - Metrics API (`Sentry.metrics()`, `IScopes.metrics()`)
-  - `IMetricsApi`, `MetricsApi` implementation
-  - Metrics types: `count`, `distribution`, `gauge`
-  - `MetricsBatchProcessor`, batching and queue management
-  - `SentryMetricsEvent`, `SentryMetricsEvents`
-  - `SentryOptions.getMetrics()`, `beforeSend` callback
-
-- **`queues`**: Use when working with:
-  - Sentry Queues product data or messaging span conventions
-  - Queue tracing spans/transactions (`queue.publish`, `queue.process`)
-  - `enableQueueTracing` option and `sentry.enable-queue-tracing`
-  - Kafka instrumentation (`sentry-kafka`, `SentryKafkaProducer`, `SentryKafkaConsumerTracing`)
-  - Spring Kafka queue auto-instrumentation and `SentryKafkaRecordInterceptor`
-  - Messaging span data (`messaging.system`, `messaging.destination.name`, receive latency, retry count)
-  - `sentry-task-enqueued-time` header and distributed trace propagation through queues
-
-- **`continuous_profiling_jvm`**: Use when working with:
-  - JVM continuous profiling (`sentry-async-profiler` module)
-  - `IContinuousProfiler`, `JavaContinuousProfiler`
-  - `ProfileChunk`, chunk rotation, JFR file handling
-  - `ProfileLifecycle` (MANUAL vs TRACE modes)
-  - async-profiler integration, ServiceLoader discovery
-  - Rate limiting, offline caching, scopes integration
-
-- **Android profiling**: There is currently no dedicated rule for this area yet.
-  - Inspect the relevant `sentry-android-core` profiling code directly
-  - Fetch other related rules as needed (for example `options`, `offline`, or `api`)
-
-### Integration & Infrastructure
-- **`opentelemetry`**: Use when working with:
-  - OpenTelemetry modules (`sentry-opentelemetry-*`)
-  - Agent vs agentless configurations
-  - Span processing, sampling, context propagation
-  - `OtelSpanFactory`, `SentrySpanExporter`
-  - Tracing, distributed tracing
-
-- **`new_module`**: Use when adding a new integration or sample module
-
-### Workflow
-- **`pr`**: Use when working with:
-  - Creating pull requests
-  - Stacked PRs, PR naming, stack comments
-  - PR changelog entries
-  - Merging or syncing stacked branches
-
-### Testing
-- **`e2e_tests`**: Use when working with:
-  - System tests, sample applications
-  - `system-test-runner.py`, mock Sentry server
-  - End-to-end test infrastructure
-  - CI system test workflows
-
-## Usage Guidelines
-
-1. **Start minimal**: Only include `coding.mdc` (auto-applied) for general tasks
-2. **Fetch on-demand**: Use `fetch_rules ["rule_name"]` when you identify specific domain work
-3. **Multiple rules**: Fetch multiple rules if task spans domains (e.g., `["scopes", "opentelemetry"]` for tracing scope issues)
-4. **Context clues**: Look for these keywords in requests to determine relevant rules:
-   - Public API/apiDump/.api files/binary compatibility/new method → `api`
-   - Options/SentryOptions/ExternalOptions/ManifestMetadataReader/sentry.properties → `options`
-   - Scope/Hub/forking → `scopes`
-   - Duplicate/dedup → `deduplication`
-   - OpenTelemetry/tracing/spans → `opentelemetry`
-   - new module/integration/sample → `new_module`
-   - Cache/offline/network → `offline`
-   - System test/e2e/sample → `e2e_tests`
-   - Feature flag/addFeatureFlag/flag evaluation → `feature_flags`
-   - Metrics/count/distribution/gauge → `metrics`
-   - Queues/queue tracing/Kafka/Spring Kafka/queue.publish/queue.process/enableQueueTracing/messaging spans → `queues`
-   - PR/pull request/stacked PR/stack → `pr`
-   - JVM continuous profiling/async-profiler/JFR/ProfileChunk → `continuous_profiling_jvm`
-   - Android continuous profiling/AndroidProfiler/frame metrics/method tracing → no dedicated rule yet; inspect the code directly
diff --git a/AGENTS.md b/AGENTS.md
index 4f938ceff2d..f785961eceb 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -2,15 +2,30 @@
 
 This file provides guidance to AI coding agents when working with code in this repository.
 
-## STOP — Required Reading (Do This First)
-
-Before doing ANYTHING else (including answering questions), you MUST use the Read tool to load these files:
-1. `.cursor/rules/coding.mdc`
-2. `.cursor/rules/overview_dev.mdc`
-
-Then identify and read any topically relevant `.cursor/rules/*.mdc` files for the area you're working on (e.g., `opentelemetry.mdc` for OTel work, `metrics.mdc` for metrics work). Use the Glob tool on `.cursor/rules/*.mdc` to discover available rule files.
-
-Do NOT skip this step. Do NOT proceed without reading these files first.
+## Domain-Specific Rules
+
+This file covers the whole repository. Before working on a specific area, read the matching
+rule file in `.cursor/rules/`:
+
+| Rule | Read it when working on |
+|---|---|
+| `api` | Public API surface, binary compatibility, `.api` files, `apiDump`, `IScope`/`IScopes`/`Sentry` static API, protocol classes |
+| `options` | `SentryOptions`, namespaced options, `ExternalOptions`, `sentry.properties`, `ManifestMetadataReader`, Spring Boot properties |
+| `scopes` | Scope management, forking, lifecycle, `ScopeType`, thread-local storage, scope bleeding, Hub → Scopes migration |
+| `deduplication` | Duplicate event detection, `DuplicateEventDetectionEventProcessor`, `enableDeduplication` |
+| `offline` | Caching, envelope storage, network failure handling, retries, `AsyncHttpTransport`, `EnvelopeCache`, rate limiting |
+| `feature_flags` | `addFeatureFlag`, `FeatureFlagBuffer`, `maxFeatureFlags`, LaunchDarkly and OpenFeature integrations |
+| `metrics` | `Sentry.metrics()`, `IMetricsApi`, count/distribution/gauge, `MetricsBatchProcessor` |
+| `queues` | Queue tracing, `queue.publish`/`queue.process`, `enableQueueTracing`, Kafka instrumentation, messaging span data |
+| `continuous_profiling_jvm` | `sentry-async-profiler`, `IContinuousProfiler`, `ProfileChunk`, JFR files, `ProfileLifecycle` |
+| `opentelemetry` | `sentry-opentelemetry-*`, agent vs agentless, span processing, sampling, context propagation |
+| `new_module` | Adding a new integration or sample module |
+| `pr` | Creating pull requests, stacked PRs, changelog entries |
+| `e2e_tests` | System tests, sample applications, `system-test-runner.py`, mock Sentry server |
+
+Rules can be combined — a tracing scope issue may need both `scopes` and `opentelemetry`.
+There is no rule for Android profiling yet; read the `sentry-android-core` profiling code
+directly and fetch related rules such as `options`, `offline`, or `api` as needed.
 
 ## Project Overview
 
diff --git a/CLAUDE.md b/CLAUDE.md
index 19507016af4..f59e5a152f3 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -2,5 +2,8 @@
 
 ## STOP — Required Reading (Do This First)
 
-Before doing ANYTHING else (including answering questions), you MUST use the Read tool to load [AGENTS.md](AGENTS.md) and follow ALL of its instructions, including reading the required `.cursor/rules/*.mdc` files it references.
-Do NOT skip this step. Do NOT proceed without reading these files first.
+Before doing ANYTHING else (including answering questions), you MUST use the Read tool to load
+[AGENTS.md](AGENTS.md) and follow ALL of its instructions. It is the single source of truth
+for build commands, contributing guidelines, workflow rules, and the index of the
+domain-specific rules.
+Do NOT skip this step. Do NOT proceed without reading it first.

From 77d4c48e3ece6daf794d74ed9be6968e323826e5 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Wed, 12 Aug 2026 10:27:38 +0200
Subject: [PATCH 382/391] perf(core): Store performance measurements as
 primitives (#5935)

* perf(core): Store performance measurements as primitives

While a transaction or profile chunk is running, performance data is
collected every 100ms for up to 30 seconds. PerformanceCollectionData
stored its measurements as boxed Double/Long, using null to mean "no
collector reported this". Heap sizes are far outside the Long cache, so
each sample allocated a box per measurement.

The fields are now primitives with an explicit presence flag, and
consumers ask hasUsedHeapMemory() instead of null-checking. A sentinel
value was considered instead, but AndroidCpuCollector can legitimately
produce NaN when it observes a zero-length interval, so no in-band value
is safe.

No behavior change: which measurements are reported, and their values,
are unchanged. PerformanceCollectionData is @ApiStatus.Internal, so the
signature changes in sentry.api are not part of the public surface.

* changelog
---
 CHANGELOG.md                                  |  1 +
 sentry-android-core/build.gradle.kts          |  1 +
 .../sentry/android/core/AndroidProfiler.java  | 18 +++----
 .../core/PerfettoContinuousProfiler.java      | 19 ++++----
 .../android/core/AndroidCpuCollectorTest.kt   | 11 ++---
 .../core/AndroidMemoryCollectorTest.kt        | 13 ++---
 .../core/ChunkMeasurementCollectorTest.kt     |  7 +--
 sentry/api/sentry.api                         | 15 +++---
 .../io/sentry/PerformanceCollectionData.java  | 47 +++++++++++++++----
 ...efaultCompositePerformanceCollectorTest.kt | 16 +++----
 .../java/io/sentry/JavaMemoryCollectorTest.kt | 10 ++--
 11 files changed, 92 insertions(+), 66 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 96504dc211f..d841fa4d866 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,6 +18,7 @@
 
 - Read the clock once per performance collection round instead of once per in-flight transaction ([#5934](https://github.com/getsentry/sentry-java/pull/5934))
 - Reduce allocations while collecting cpu usage during transactions by reading the process cpu time via `Process.getElapsedCpuTime()` instead of parsing `/proc/self/stat` (33.6kB to 16 bytes per sample on a Pixel 3) ([#5926](https://github.com/getsentry/sentry-java/pull/5926))
+- Store performance measurements as primitives, removing a boxed allocation per measurement per performance sample ([#5935](https://github.com/getsentry/sentry-java/pull/5935))
 
 ### Dependencies
 
diff --git a/sentry-android-core/build.gradle.kts b/sentry-android-core/build.gradle.kts
index 23248d6dae4..0e3708a89bf 100644
--- a/sentry-android-core/build.gradle.kts
+++ b/sentry-android-core/build.gradle.kts
@@ -115,6 +115,7 @@ dependencies {
   testImplementation(libs.androidx.test.ext.junit)
   testImplementation(libs.androidx.test.runner)
   testImplementation(libs.awaitility.kotlin)
+  testImplementation(libs.google.truth)
   testImplementation(libs.mockito.kotlin)
   testImplementation(libs.mockito.inline)
   testImplementation(projects.sentryTestSupport)
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidProfiler.java
index f4357b010f7..3f569df5378 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/AndroidProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/AndroidProfiler.java
@@ -322,21 +322,21 @@ private void putPerformanceCollectionDataInMeasurements(
         for (final @NotNull PerformanceCollectionData data : performanceCollectionData) {
           final long nanoTimestamp = data.getNanoTimestamp();
           final long relativeStartNs = nanoTimestamp + timestampDiff;
-          final @Nullable Double cpuUsagePercentage = data.getCpuUsagePercentage();
-          final @Nullable Long usedHeapMemory = data.getUsedHeapMemory();
-          final @Nullable Long usedNativeMemory = data.getUsedNativeMemory();
 
-          if (cpuUsagePercentage != null) {
+          if (data.hasCpuUsagePercentage()) {
             cpuUsageMeasurements.add(
-                new ProfileMeasurementValue(relativeStartNs, cpuUsagePercentage, nanoTimestamp));
+                new ProfileMeasurementValue(
+                    relativeStartNs, data.getCpuUsagePercentage(), nanoTimestamp));
           }
-          if (usedHeapMemory != null) {
+          if (data.hasUsedHeapMemory()) {
             memoryUsageMeasurements.add(
-                new ProfileMeasurementValue(relativeStartNs, usedHeapMemory, nanoTimestamp));
+                new ProfileMeasurementValue(
+                    relativeStartNs, data.getUsedHeapMemory(), nanoTimestamp));
           }
-          if (usedNativeMemory != null) {
+          if (data.hasUsedNativeMemory()) {
             nativeMemoryUsageMeasurements.add(
-                new ProfileMeasurementValue(relativeStartNs, usedNativeMemory, nanoTimestamp));
+                new ProfileMeasurementValue(
+                    relativeStartNs, data.getUsedNativeMemory(), nanoTimestamp));
           }
         }
       }
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
index d4260e93dd7..731be774339 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/PerfettoContinuousProfiler.java
@@ -609,21 +609,20 @@ private static void addPerformanceDataToMeasurements(
           final long sampleElapsedRealtimeNanos = elapsedRealtimeNowNanos - nanosSinceSample;
           final long relativeStartNs =
               sampleElapsedRealtimeNanos - profileStartElapsedRealtimeNanos;
-          final @Nullable Double cpuUsagePercentage = data.getCpuUsagePercentage();
-          final @Nullable Long usedHeapMemory = data.getUsedHeapMemory();
-          final @Nullable Long usedNativeMemory = data.getUsedNativeMemory();
-
-          if (cpuUsagePercentage != null) {
+          if (data.hasCpuUsagePercentage()) {
             cpuUsageMeasurements.addLast(
-                new ProfileMeasurementValue(relativeStartNs, cpuUsagePercentage, nanoTimestamp));
+                new ProfileMeasurementValue(
+                    relativeStartNs, data.getCpuUsagePercentage(), nanoTimestamp));
           }
-          if (usedHeapMemory != null) {
+          if (data.hasUsedHeapMemory()) {
             memoryUsageMeasurements.addLast(
-                new ProfileMeasurementValue(relativeStartNs, usedHeapMemory, nanoTimestamp));
+                new ProfileMeasurementValue(
+                    relativeStartNs, data.getUsedHeapMemory(), nanoTimestamp));
           }
-          if (usedNativeMemory != null) {
+          if (data.hasUsedNativeMemory()) {
             nativeMemoryUsageMeasurements.addLast(
-                new ProfileMeasurementValue(relativeStartNs, usedNativeMemory, nanoTimestamp));
+                new ProfileMeasurementValue(
+                    relativeStartNs, data.getUsedNativeMemory(), nanoTimestamp));
           }
         }
       }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidCpuCollectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidCpuCollectorTest.kt
index 1b855aabc6c..422eb1ca804 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidCpuCollectorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidCpuCollectorTest.kt
@@ -1,13 +1,11 @@
 package io.sentry.android.core
 
+import com.google.common.truth.Truth.assertThat
 import io.sentry.ILogger
 import io.sentry.PerformanceCollectionData
 import io.sentry.test.getCtor
 import kotlin.test.Test
 import kotlin.test.assertFailsWith
-import kotlin.test.assertNotEquals
-import kotlin.test.assertNotNull
-import kotlin.test.assertNull
 import org.mockito.kotlin.mock
 
 class AndroidCpuCollectorTest {
@@ -30,7 +28,7 @@ class AndroidCpuCollectorTest {
   fun `collect works only after setup`() {
     val data = PerformanceCollectionData(10)
     fixture.getSut().collect(data)
-    assertNull(data.cpuUsagePercentage)
+    assertThat(data.hasCpuUsagePercentage()).isFalse()
   }
 
   @Test
@@ -39,8 +37,7 @@ class AndroidCpuCollectorTest {
     val collector = fixture.getSut()
     collector.setup()
     collector.collect(data)
-    val cpuData = data.cpuUsagePercentage
-    assertNotNull(cpuData)
-    assertNotEquals(0.0, cpuData)
+    assertThat(data.hasCpuUsagePercentage()).isTrue()
+    assertThat(data.cpuUsagePercentage).isNotEqualTo(0.0)
   }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidMemoryCollectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidMemoryCollectorTest.kt
index 23214c040c8..4a7a621ede2 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/AndroidMemoryCollectorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/AndroidMemoryCollectorTest.kt
@@ -1,11 +1,9 @@
 package io.sentry.android.core
 
 import android.os.Debug
+import com.google.common.truth.Truth.assertThat
 import io.sentry.PerformanceCollectionData
 import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNotEquals
-import kotlin.test.assertNotNull
 
 class AndroidMemoryCollectorTest {
   private val fixture = Fixture()
@@ -21,10 +19,9 @@ class AndroidMemoryCollectorTest {
     val usedNativeMemory = Debug.getNativeHeapSize() - Debug.getNativeHeapFreeSize()
     val usedMemory = fixture.runtime.totalMemory() - fixture.runtime.freeMemory()
     fixture.collector.collect(data)
-    assertNotNull(data.usedHeapMemory)
-    assertNotNull(data.usedNativeMemory)
-    assertNotEquals(-1, data.usedNativeMemory)
-    assertEquals(usedNativeMemory, data.usedNativeMemory)
-    assertEquals(usedMemory, data.usedHeapMemory)
+    assertThat(data.hasUsedHeapMemory()).isTrue()
+    assertThat(data.hasUsedNativeMemory()).isTrue()
+    assertThat(data.usedNativeMemory).isEqualTo(usedNativeMemory)
+    assertThat(data.usedHeapMemory).isEqualTo(usedMemory)
   }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/ChunkMeasurementCollectorTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/ChunkMeasurementCollectorTest.kt
index ffc00907460..0841f974961 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/ChunkMeasurementCollectorTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/ChunkMeasurementCollectorTest.kt
@@ -111,11 +111,12 @@ class ChunkMeasurementCollectorTest {
    */
   private fun futureFrameEndNanos() = System.nanoTime() + TimeUnit.MINUTES.toNanos(1)
 
+  /** A null measurement is left unset, as it would be by a collector that did not report it. */
   private fun perfData(nanos: Long, cpu: Double?, heap: Long?, native: Long?) =
     PerformanceCollectionData(nanos).apply {
-      cpuUsagePercentage = cpu
-      usedHeapMemory = heap
-      usedNativeMemory = native
+      cpu?.let { cpuUsagePercentage = it }
+      heap?.let { usedHeapMemory = it }
+      native?.let { usedNativeMemory = it }
     }
 
   private fun assertChunkCounts(
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 3f8176de977..638fe671d9b 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -2095,13 +2095,16 @@ public final class io/sentry/OutboxSender : io/sentry/IEnvelopeSender {
 
 public final class io/sentry/PerformanceCollectionData {
 	public fun <init> (J)V
-	public fun getCpuUsagePercentage ()Ljava/lang/Double;
+	public fun getCpuUsagePercentage ()D
 	public fun getNanoTimestamp ()J
-	public fun getUsedHeapMemory ()Ljava/lang/Long;
-	public fun getUsedNativeMemory ()Ljava/lang/Long;
-	public fun setCpuUsagePercentage (Ljava/lang/Double;)V
-	public fun setUsedHeapMemory (Ljava/lang/Long;)V
-	public fun setUsedNativeMemory (Ljava/lang/Long;)V
+	public fun getUsedHeapMemory ()J
+	public fun getUsedNativeMemory ()J
+	public fun hasCpuUsagePercentage ()Z
+	public fun hasUsedHeapMemory ()Z
+	public fun hasUsedNativeMemory ()Z
+	public fun setCpuUsagePercentage (D)V
+	public fun setUsedHeapMemory (J)V
+	public fun setUsedNativeMemory (J)V
 }
 
 public final class io/sentry/ProfileChunk : io/sentry/JsonSerializable, io/sentry/JsonUnknown {
diff --git a/sentry/src/main/java/io/sentry/PerformanceCollectionData.java b/sentry/src/main/java/io/sentry/PerformanceCollectionData.java
index bc32fcd820a..365cacbeb6f 100644
--- a/sentry/src/main/java/io/sentry/PerformanceCollectionData.java
+++ b/sentry/src/main/java/io/sentry/PerformanceCollectionData.java
@@ -1,13 +1,22 @@
 package io.sentry;
 
 import org.jetbrains.annotations.ApiStatus;
-import org.jetbrains.annotations.Nullable;
 
+/**
+ * Holds a single performance measurement sample.
+ *
+ * <p>Measurements are stored as primitives with a separate presence flag, rather than as boxed
+ * nullable types, because an instance is created every 100ms for as long as a transaction or
+ * profile chunk is running.
+ */
 @ApiStatus.Internal
 public final class PerformanceCollectionData {
-  private @Nullable Double cpuUsagePercentage = null;
-  private @Nullable Long usedHeapMemory = null;
-  private @Nullable Long usedNativeMemory = null;
+  private double cpuUsagePercentage;
+  private boolean hasCpuUsagePercentage;
+  private long usedHeapMemory;
+  private boolean hasUsedHeapMemory;
+  private long usedNativeMemory;
+  private boolean hasUsedNativeMemory;
   private final long nanoTimestamp;
 
   public PerformanceCollectionData(final long nanoTimestamp) {
@@ -15,30 +24,48 @@ public PerformanceCollectionData(final long nanoTimestamp) {
   }
 
   /** Set the cpu usage percentage. */
-  public void setCpuUsagePercentage(final @Nullable Double cpuUsagePercentage) {
+  public void setCpuUsagePercentage(final double cpuUsagePercentage) {
     this.cpuUsagePercentage = cpuUsagePercentage;
+    this.hasCpuUsagePercentage = true;
   }
 
-  public @Nullable Double getCpuUsagePercentage() {
+  /** Only meaningful when {@link #hasCpuUsagePercentage()} is true. */
+  public double getCpuUsagePercentage() {
     return cpuUsagePercentage;
   }
 
-  public void setUsedHeapMemory(final @Nullable Long usedHeapMemory) {
+  public boolean hasCpuUsagePercentage() {
+    return hasCpuUsagePercentage;
+  }
+
+  public void setUsedHeapMemory(final long usedHeapMemory) {
     this.usedHeapMemory = usedHeapMemory;
+    this.hasUsedHeapMemory = true;
   }
 
-  public @Nullable Long getUsedHeapMemory() {
+  /** Only meaningful when {@link #hasUsedHeapMemory()} is true. */
+  public long getUsedHeapMemory() {
     return usedHeapMemory;
   }
 
-  public void setUsedNativeMemory(final @Nullable Long usedNativeMemory) {
+  public boolean hasUsedHeapMemory() {
+    return hasUsedHeapMemory;
+  }
+
+  public void setUsedNativeMemory(final long usedNativeMemory) {
     this.usedNativeMemory = usedNativeMemory;
+    this.hasUsedNativeMemory = true;
   }
 
-  public @Nullable Long getUsedNativeMemory() {
+  /** Only meaningful when {@link #hasUsedNativeMemory()} is true. */
+  public long getUsedNativeMemory() {
     return usedNativeMemory;
   }
 
+  public boolean hasUsedNativeMemory() {
+    return hasUsedNativeMemory;
+  }
+
   public long getNanoTimestamp() {
     return nanoTimestamp;
   }
diff --git a/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt b/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
index bd1e584c2d7..d259100853c 100644
--- a/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
+++ b/sentry/src/test/java/io/sentry/DefaultCompositePerformanceCollectorTest.kt
@@ -173,12 +173,12 @@ class DefaultCompositePerformanceCollectorTest {
     assertNotNull(data1)
     assertNotNull(data2)
     assertNotNull(data3)
-    assertFalse(data1.mapNotNull { it.usedHeapMemory }.isEmpty())
-    assertFalse(data1.mapNotNull { it.cpuUsagePercentage }.isEmpty())
-    assertFalse(data2.mapNotNull { it.usedHeapMemory }.isEmpty())
-    assertFalse(data2.mapNotNull { it.cpuUsagePercentage }.isEmpty())
-    assertFalse(data3.mapNotNull { it.usedHeapMemory }.isEmpty())
-    assertFalse(data3.mapNotNull { it.cpuUsagePercentage }.isEmpty())
+    assertTrue(data1.any { it.hasUsedHeapMemory() })
+    assertTrue(data1.any { it.hasCpuUsagePercentage() })
+    assertTrue(data2.any { it.hasUsedHeapMemory() })
+    assertTrue(data2.any { it.hasCpuUsagePercentage() })
+    assertTrue(data3.any { it.hasUsedHeapMemory() })
+    assertTrue(data3.any { it.hasCpuUsagePercentage() })
   }
 
   @Test
@@ -266,8 +266,8 @@ class DefaultCompositePerformanceCollectorTest {
     Thread.sleep(300)
     val data1 = collector.stop(fixture.transaction1)
     assertNotNull(data1)
-    val memoryData = data1.map { it.usedHeapMemory }
-    val cpuData = data1.map { it.cpuUsagePercentage }
+    val memoryData = data1.filter { it.hasUsedHeapMemory() }
+    val cpuData = data1.filter { it.hasCpuUsagePercentage() }
 
     // The data returned by the collector is not empty
     assertFalse(memoryData.isEmpty())
diff --git a/sentry/src/test/java/io/sentry/JavaMemoryCollectorTest.kt b/sentry/src/test/java/io/sentry/JavaMemoryCollectorTest.kt
index 5f4aa7fb030..7f2b593b9a5 100644
--- a/sentry/src/test/java/io/sentry/JavaMemoryCollectorTest.kt
+++ b/sentry/src/test/java/io/sentry/JavaMemoryCollectorTest.kt
@@ -1,8 +1,7 @@
 package io.sentry
 
+import com.google.common.truth.Truth.assertThat
 import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertNull
 
 class JavaMemoryCollectorTest {
   private val fixture = Fixture()
@@ -17,8 +16,9 @@ class JavaMemoryCollectorTest {
     val data = PerformanceCollectionData(10)
     val usedMemory = fixture.runtime.totalMemory() - fixture.runtime.freeMemory()
     fixture.collector.collect(data)
-    assertNull(data.usedNativeMemory)
-    assertEquals(usedMemory, data.usedHeapMemory)
-    assertEquals(10, data.nanoTimestamp)
+    assertThat(data.hasUsedNativeMemory()).isFalse()
+    assertThat(data.hasUsedHeapMemory()).isTrue()
+    assertThat(data.usedHeapMemory).isEqualTo(usedMemory)
+    assertThat(data.nanoTimestamp).isEqualTo(10)
   }
 }

From d08313e65f7d8f668328b00851f844e813610325 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Wed, 12 Aug 2026 12:15:35 +0200
Subject: [PATCH 383/391] feat(core): Add ExceptionUtils.handleFatal to rethrow
 non-recoverable throwables (#5907)

* feat(core): Add ExceptionUtils.handleFatal to rethrow non-recoverable throwables

* refactor(core): Rename ExceptionUtils.handleFatal to rethrowIfFatal

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* feat(core): Rethrow LinkageError from ExceptionUtils.rethrowIfFatal

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 sentry/api/sentry.api                         |  1 +
 .../java/io/sentry/util/ExceptionUtils.java   | 30 ++++++++++
 .../java/io/sentry/util/ExceptionUtilsTest.kt | 58 +++++++++++++++++++
 3 files changed, 89 insertions(+)

diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 638fe671d9b..774bfd90bf3 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -7710,6 +7710,7 @@ public final class io/sentry/util/ExceptionUtils {
 	public fun <init> ()V
 	public static fun findRootCause (Ljava/lang/Throwable;)Ljava/lang/Throwable;
 	public static fun isIgnored (Ljava/util/Set;Ljava/lang/Throwable;)Z
+	public static fun rethrowIfFatal (Ljava/lang/Throwable;)V
 }
 
 public final class io/sentry/util/FileUtils {
diff --git a/sentry/src/main/java/io/sentry/util/ExceptionUtils.java b/sentry/src/main/java/io/sentry/util/ExceptionUtils.java
index 9d6033a96c3..329bc84ba81 100644
--- a/sentry/src/main/java/io/sentry/util/ExceptionUtils.java
+++ b/sentry/src/main/java/io/sentry/util/ExceptionUtils.java
@@ -29,4 +29,34 @@ public static boolean isIgnored(
       final @NotNull Throwable throwable) {
     return ignoredExceptionsForType.contains(throwable.getClass());
   }
+
+  /**
+   * Rethrows non-recoverable {@link Throwable}s that should never be swallowed: {@link
+   * VirtualMachineError} (e.g. OutOfMemoryError/StackOverflowError), {@link ThreadDeath} and {@link
+   * LinkageError} are rethrown as-is. For {@link InterruptedException}, the thread's interrupted
+   * status is restored instead of rethrowing, since it is a checked exception. All other throwables
+   * are left untouched for the caller to handle/log/ignore as before.
+   *
+   * <p>Note on {@link LinkageError}: its subclasses (e.g. {@link NoClassDefFoundError}, {@link
+   * NoSuchMethodError}, {@link AbstractMethodError}, {@link UnsatisfiedLinkError}) are also the
+   * expected runtime signal for a missing or version-mismatched optional dependency, which is a
+   * normal condition for integrations built against {@code compileOnly} dependencies. Call sites
+   * that probe for such a dependency must catch the relevant {@link LinkageError} subclass locally
+   * <em>before</em> delegating to this method — see {@code SentrySQLiteDriver.hasConnectionPool}
+   * and {@link LoadClass} for examples.
+   *
+   * @param throwable - the throwable to check
+   */
+  public static void rethrowIfFatal(final @NotNull Throwable throwable) {
+    // VirtualMachineError covers OutOfMemoryError, StackOverflowError, InternalError, and
+    // UnknownError
+    if (throwable instanceof VirtualMachineError
+        || throwable instanceof ThreadDeath
+        || throwable instanceof LinkageError) {
+      throw (Error) throwable;
+    }
+    if (throwable instanceof InterruptedException) {
+      Thread.currentThread().interrupt();
+    }
+  }
 }
diff --git a/sentry/src/test/java/io/sentry/util/ExceptionUtilsTest.kt b/sentry/src/test/java/io/sentry/util/ExceptionUtilsTest.kt
index 7517c243497..13f2cffc142 100644
--- a/sentry/src/test/java/io/sentry/util/ExceptionUtilsTest.kt
+++ b/sentry/src/test/java/io/sentry/util/ExceptionUtilsTest.kt
@@ -1,8 +1,13 @@
 package io.sentry.util
 
+import com.google.common.truth.Truth.assertThat
 import java.lang.RuntimeException
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertFails
+import kotlin.test.assertFailsWith
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
 
 class ExceptionUtilsTest {
   @Test
@@ -18,4 +23,57 @@ class ExceptionUtilsTest {
     val ex = RuntimeException(cause)
     assertEquals(rootCause, ExceptionUtils.findRootCause(ex))
   }
+
+  @Test
+  fun `rethrowIfFatal rethrows OutOfMemoryError`() {
+    assertFails { ExceptionUtils.rethrowIfFatal(OutOfMemoryError()) }
+  }
+
+  @Test
+  fun `rethrowIfFatal rethrows StackOverflowError`() {
+    assertFails { ExceptionUtils.rethrowIfFatal(StackOverflowError()) }
+  }
+
+  @Test
+  fun `rethrowIfFatal rethrows ThreadDeath`() {
+    assertFails { ExceptionUtils.rethrowIfFatal(ThreadDeath()) }
+  }
+
+  @Test
+  fun `rethrowIfFatal rethrows NoClassDefFoundError as-is`() {
+    val error = NoClassDefFoundError()
+    val thrown = assertFailsWith<NoClassDefFoundError> { ExceptionUtils.rethrowIfFatal(error) }
+    assertThat(thrown).isSameInstanceAs(error)
+  }
+
+  @Test
+  fun `rethrowIfFatal rethrows NoSuchMethodError as-is`() {
+    val error = NoSuchMethodError()
+    val thrown = assertFailsWith<NoSuchMethodError> { ExceptionUtils.rethrowIfFatal(error) }
+    assertThat(thrown).isSameInstanceAs(error)
+  }
+
+  @Test
+  fun `rethrowIfFatal rethrows UnsatisfiedLinkError as-is`() {
+    val error = UnsatisfiedLinkError()
+    val thrown = assertFailsWith<UnsatisfiedLinkError> { ExceptionUtils.rethrowIfFatal(error) }
+    assertThat(thrown).isSameInstanceAs(error)
+  }
+
+  @Test
+  fun `rethrowIfFatal restores interrupt flag for InterruptedException without rethrowing`() {
+    try {
+      ExceptionUtils.rethrowIfFatal(InterruptedException())
+      assertTrue(Thread.currentThread().isInterrupted)
+    } finally {
+      // clear the interrupt flag so it doesn't leak into other tests
+      Thread.interrupted()
+    }
+  }
+
+  @Test
+  fun `rethrowIfFatal does nothing for regular exceptions`() {
+    ExceptionUtils.rethrowIfFatal(RuntimeException())
+    assertFalse(Thread.currentThread().isInterrupted)
+  }
 }

From 4d15f0e2bb6ce322312e33014025dda3510726d5 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Wed, 12 Aug 2026 13:13:40 +0200
Subject: [PATCH 384/391] docs: Add develop-docs with Perfetto profiling
 documentation (#5750)

---
 develop-docs/README.md                     | 149 +++++++++++++
 develop-docs/feature/profiling/perfetto.md | 232 +++++++++++++++++++++
 develop-docs/general/pipeline.md           | 121 +++++++++++
 3 files changed, 502 insertions(+)
 create mode 100644 develop-docs/README.md
 create mode 100644 develop-docs/feature/profiling/perfetto.md
 create mode 100644 develop-docs/general/pipeline.md

diff --git a/develop-docs/README.md b/develop-docs/README.md
new file mode 100644
index 00000000000..b9c2c7913ca
--- /dev/null
+++ b/develop-docs/README.md
@@ -0,0 +1,149 @@
+# Develop Docs
+
+This folder holds internal developer documentation for the Sentry Java/Android SDK:
+architecture notes, feature deep-dives, design decisions, and cross-module concepts
+that don't belong in the public [Sentry docs](https://docs.sentry.io) or in inline
+code comments.
+
+If you are documenting **how** or **why** something works for the people who maintain
+this SDK, it goes here. If you are documenting **how to use** the SDK for end users,
+it belongs in the public docs instead.
+
+## Rules
+
+These rules keep the docs consistent, easy to navigate, and easy to grep.
+
+### Directory structure
+
+Documents live in **subdirectories**, one level per level of grouping. Directories are
+cheap: reach for a new one as soon as a topic has more than one document, or as soon as you
+can name the group.
+
+Every document sits under one of these top-level categories:
+
+- `general/` — cross-cutting topics (e.g. `general/architecture.md`, `general/pipeline.md`)
+- `feature/` — a specific SDK feature (e.g. `feature/errors/`, `feature/profiling/`)
+- `integration/` — a specific integration or module (e.g. `integration/opentelemetry/`, `integration/spring/`)
+- `platform/` — platform-specific concerns (e.g. `platform/android/`, `platform/jvm/`)
+- `process/` — team processes and workflows (e.g. `process/release.md`)
+
+Add a new category only when an existing one clearly does not fit, and keep the list above
+up to date.
+
+Below the category, nest by topic and then by sub-topic. A fully grown feature might look
+like this:
+
+```text
+develop-docs/
+  README.md
+  general/
+    pipeline.md
+  feature/
+    profiling/
+      overview.md
+      perfetto.md
+      anr.md
+      symbolication/
+        deobfuscation.md
+```
+
+- Give a directory an `overview.md` once it holds several documents, and link to its
+  siblings from there.
+- Do not create a directory that will only ever hold one document — put the document
+  directly in the category (`general/pipeline.md`, not `general/pipeline/pipeline.md`).
+
+### File naming
+
+- File names are **lowercase**, except for this `README.md`, which GitHub renders as the
+  folder's landing page.
+- Use **dashes** (`-`) as separators, never underscores or spaces. For example, use
+  `session-replay.md`, not `session_replay.md` or `Session Replay.md`.
+- Use the `.md` extension for all text documents.
+- **Do not repeat the path in the file name.** The directories carry the namespace, so the
+  file name only needs the part that distinguishes it from its siblings:
+  `feature/profiling/perfetto.md`, not `feature/profiling/perfetto-profiling.md`.
+- Choose short, descriptive names (`feature/replay/masking.md`, not
+  `feature/replay/how-masking-works.md`).
+
+### Images and other assets
+
+- When a document embeds images (or other binary assets), store them in an **`assets/`
+  folder next to the document**. Documents in the same directory share it:
+
+  ```text
+  develop-docs/
+    feature/
+      profiling/
+        perfetto.md
+        assets/
+          pipeline.png
+          overview.svg
+  ```
+
+- Reference assets with **relative paths**: `![Profiling pipeline](assets/pipeline.png)`.
+- Asset file names follow the same rules as documents: lowercase, dashes, descriptive.
+- Prefer **vector formats** (SVG) for diagrams and screenshots where practical
+- Prefer **Mermaid** over a static image whenever a diagram can be expressed as one
+  (see below) — it lives in the document, is versioned as text, and is easy to update.
+
+### Writing style
+
+- Write in the **present tense** and the **active voice**. Describe how the system
+  behaves now ("The transport retries failed envelopes"), not how it will or did behave.
+  This way there's no need to update the docs once a feature ships.
+- Keep one **top-level `# ` heading** per document (the title), and nest sections with
+  `##`, `###`, etc. Do not skip heading levels.
+- Keep documents focused on a **single topic**. Split large topics into several documents
+  in a shared directory and link between them rather than growing one giant file.
+- Use fenced **code blocks with a language identifier** (```kotlin `,
+  ` ```bash `) so syntax highlighting works.
+- Prefer Kotlin snippets over Java.
+- When referencing code, link to the file with a **relative path** (e.g.
+  `../../../sentry/src/main/java/io/sentry/Sentry.java`) rather than pasting large excerpts
+  that fall out of date. Count the `../` from the document's own directory.
+- Avoid pinning content to a specific SDK version or date unless it is genuinely
+  version-specific; keep docs evergreen.
+- Cross-link related documents with relative links (e.g.
+  `[the ingestion pipeline](../../general/pipeline.md)`).
+
+### Structuring a feature document
+
+Most feature documents answer the same four questions, and following that order makes them
+easier to compare and to keep current:
+
+1. **Surface area** — where and when the SDK collects the data.
+2. **Collection** — how the SDK collects it.
+3. **Format** — what the collected data looks like on the wire.
+4. **Pipeline** — how the backend ingests, stores, and serves it.
+
+Do not restate (4) in every document. Describe the shared path once in
+[general/pipeline.md](general/pipeline.md) and cover only the deviations a feature
+introduces. Omit any of the four that a feature does not have, and keep each as high-level
+as the topic allows so the document stays true for longer.
+
+### Diagrams with Mermaid
+
+- Prefer [Mermaid](https://mermaid.js.org/) for diagrams. It renders directly on GitHub
+  and lives in the document as text, so it versions and reviews like code.
+- Embed a Mermaid diagram in a fenced block tagged `mermaid`:
+
+  ````markdown
+  ```mermaid
+  flowchart LR
+    Event[SentryEvent] --> Processor[EventProcessors]
+    Processor --> Transport
+    Transport --> Sentry[(Sentry)]
+  ```
+  ````
+
+- For complex diagrams, include a link to the [Mermaid Live Editor](https://mermaid.live/)
+  so reviewers can iterate quickly.
+- Fall back to static images (stored per the asset rules above) if mermaid is not practicable.
+
+## Adding a new document
+
+1. Pick the right top-level category (or introduce a new one and document it above).
+2. Pick or create the topic directory below it.
+3. Create the document, naming it for what distinguishes it from its siblings.
+4. If the directory now holds several documents, add or update its `overview.md`.
+5. If the document embeds assets, put them in an `assets/` folder next to it.
diff --git a/develop-docs/feature/profiling/perfetto.md b/develop-docs/feature/profiling/perfetto.md
new file mode 100644
index 00000000000..d4168f8f2a4
--- /dev/null
+++ b/develop-docs/feature/profiling/perfetto.md
@@ -0,0 +1,232 @@
+# Perfetto profiling on Android
+
+This document describes how continuous profiling works on Android when the SDK
+captures traces through the OS-level [`android.os.ProfilingManager`](https://developer.android.com/reference/android/os/ProfilingManager)
+API (available on API 35+), and how a captured **profile chunk** flows all the way
+from the device to a downloadable profile in Sentry.
+
+## What Perfetto is
+
+[Perfetto](https://perfetto.dev/) is Google's tracing framework for Android and Linux, and
+the tooling Android itself is instrumented with. Its
+[callstack sampler](https://perfetto.dev/docs/getting-started/cpu-profiling) interrupts the
+app at a fixed frequency, records the native and Java call stacks of the running threads,
+and writes them to a binary `.pftrace` file (a serialized
+[Perfetto protobuf](https://perfetto.dev/docs/reference/trace-packet-proto)).
+Starting with Android 15, apps can request such traces at
+runtime via `ProfilingManager` without root or `adb`, which is what makes on-device
+continuous profiling possible.
+
+Useful Perfetto references:
+
+- Perfetto docs: https://perfetto.dev/docs/
+- CPU profiling with Perfetto: https://perfetto.dev/docs/getting-started/cpu-profiling
+- Trace format (`TracePacket` proto): https://perfetto.dev/docs/reference/trace-packet-proto
+- Perfetto UI (to open a downloaded `.pftrace`): https://ui.perfetto.dev/
+
+## Pipeline overview
+
+Profile chunks travel the standard ingestion path described in
+[general/pipeline.md](../../general/pipeline.md) — SDK envelope,
+[Relay](https://develop.sentry.dev/ingestion/relay/) (Sentry's ingestion proxy), Kafka, a
+monolith processing task, then storage and a read API. Read that first; the rest of this
+document covers only where Perfetto deviates from it.
+
+The deviations are:
+
+- The envelope item carries **JSON and raw binary in one payload**, subdivided by a
+  `meta_length` header rather than base64-encoding the trace ([details](#envelope-format-and-the-meta_length-header)).
+- Relay **converts** the Perfetto trace into the existing Sample v2 profile format, and
+  additionally **keeps the raw `.pftrace`** in the object store so it can be downloaded
+  later ([details](#relay-getsentryrelay)).
+
+```mermaid
+flowchart TD
+    subgraph device["Android device — sentry-java"]
+        PM[android.os.ProfilingManager]
+        PP[PerfettoProfiler]
+        PCP[PerfettoContinuousProfiler]
+        PC[ProfileChunk]
+        ENV["Envelope item<br/>[JSON metadata][raw .pftrace]<br/>header: meta_length"]
+        PM --> PP --> PCP --> PC --> ENV
+    end
+
+    subgraph relay["Relay (processing mode)"]
+        SPLIT[Split payload at meta_length]
+        CONV[Convert Perfetto → Sample v2]
+        OS1[Upload raw .pftrace to object store]
+        KAFKA[["Kafka topic: profiles<br/>ProfileChunkKafkaMessage<br/>(Sample v2 + attachment stored_id)"]]
+        SPLIT --> CONV --> KAFKA
+        SPLIT --> OS1
+    end
+
+    subgraph monolith["Monolith — getsentry/sentry"]
+        TASK[process_profile_task]
+        SYM[Symbolicate / deobfuscate]
+        VR[vroomrs: parse + normalize]
+        OS2[(Object store)]
+        SNUBA[(Snuba: function metrics)]
+        DB[(ProfileChunkAttachment row)]
+        TASK --> SYM --> VR
+        VR --> OS2
+        VR --> SNUBA
+        TASK --> DB
+    end
+
+    ENV -->|envelope| relay
+    KAFKA --> TASK
+    OS1 -.stored_id.-> DB
+    VROOM[getsentry/vroom<br/>serve + merge flamegraphs]
+    OS2 --> VROOM
+    SNUBA --> VROOM
+```
+
+## SDK (getsentry/sentry-java)
+
+On API 35+, [`AndroidOptionsInitializer`](../../../sentry-android-core/src/main/java/io/sentry/android/core/AndroidOptionsInitializer.java)
+wires up `PerfettoContinuousProfiler` automatically. On older devices the SDK falls back
+to the legacy `Debug`-based [`AndroidContinuousProfiler`](../../../sentry-android-core/src/main/java/io/sentry/android/core/AndroidContinuousProfiler.java),
+gated by the `enableLegacyProfiling` option (manifest key
+`io.sentry.profiling.enable-legacy-profiling`, defaults to `true`). Only **continuous
+profiling** is supported on the Perfetto path — transaction-based and app-start profiling
+are not.
+
+### Capturing chunks
+
+Continuous profiling emits a stream of independent [`ProfileChunk`](../../../sentry/src/main/java/io/sentry/ProfileChunk.java)s
+rather than one profile per transaction. `PerfettoContinuousProfiler` drives a chained
+loop: each chunk runs for `MAX_CHUNK_DURATION_MILLIS` (60s) via `PerfettoProfiler`, which
+calls `ProfilingManager.requestProfiling(PROFILING_TYPE_STACK_SAMPLING, …)` at
+`PROFILING_FREQUENCY_HZ` (101 Hz). When a chunk's trace file is ready, a new chunk starts,
+so profiling runs continuously.
+
+A chunk keeps a stable `profilerId` across the session and a per-chunk `chunkId`. When the
+OS produces the trace file, the profiler builds a `ProfileChunk` tagged with the Perfetto
+content type:
+
+```kotlin
+ProfileChunk.Builder(profilerId, chunkId, measurements, traceFile, timestamp, ProfileChunk.PLATFORM_ANDROID)
+    .setContentType(ProfileChunk.CONTENT_TYPE_PERFETTO) // "application/x-perfetto-trace"
+    .build()
+```
+
+The chunk is captured via `scopes.captureProfileChunk(...)` and sent as its own envelope
+with item type [`SentryItemType.ProfileChunk`](../../../sentry/src/main/java/io/sentry/SentryItemType.java)
+(wire name `profile_chunk`).
+
+### Envelope format and the `meta_length` header
+
+A legacy chunk base64-encodes its trace into the `ProfileChunk` JSON. A Perfetto chunk is
+much larger, so [`SentryClient`](../../../sentry/src/main/java/io/sentry/SentryClient.java) instead
+routes it through the new `SentryEnvelopeItem.fromPerfettoProfileChunk(...)` factory, which
+avoids base64 by sending the raw binary alongside the JSON.
+
+The trick is a single envelope **item** whose payload concatenates the JSON metadata and
+the raw `.pftrace` bytes with **no delimiter**:
+
+```text
+[ProfileChunk JSON bytes][raw .pftrace binary bytes]
+```
+
+A new `meta_length` property on the [envelope item header](../../../sentry/src/main/java/io/sentry/SentryEnvelopeItemHeader.java)
+tells the server where the JSON ends and the binary begins. The standard envelope item
+structure (header line + newline + payload) is unchanged; `meta_length` simply subdivides
+the payload:
+
+```text
+{"type":"profile_chunk","content_type":"application/x-perfetto-trace","filename":"…","length":<total>,"meta_length":<json bytes>}
+<ProfileChunk JSON><raw perfetto binary>
+```
+
+- `length` — total payload size (JSON + binary), as for any envelope item.
+- `meta_length` — byte length of the JSON prefix. It is only known after the payload is
+  serialized, so the header computes it lazily (via a `Callable<Integer>`) and omits the
+  field entirely for non-Perfetto items, keeping the change backward compatible.
+
+## Relay (getsentry/relay)
+
+In processing mode Relay:
+
+1. **Splits** the compound item payload at `meta_length` into `(metadata JSON, raw profile)`
+   and reads `content_type: "perfetto"` from the metadata.
+2. **Converts** the binary Perfetto trace into the existing **Sample v2** profile JSON
+   format (`relay_profiling::expand_perfetto(...)`, backed by a checked-in subset of the
+   Perfetto protobuf definitions).
+3. **Uploads** the raw `.pftrace` blob to object store (usecase `profiles`, keyed per
+   org/project, with an attachment-retention TTL).
+4. **Produces** a `ProfileChunkKafkaMessage` to the `profiles` Kafka topic. The message
+   carries the expanded Sample v2 JSON as `payload` plus an `attachments` array, where each
+   attachment records:
+   - `name` (e.g. `profile.perfetto`),
+   - `content_type` (e.g. `application/x-perfetto-trace`),
+   - `stored_id` — the object store key of the uploaded raw blob.
+
+```json
+{
+  "organization_id": 1,
+  "project_id": 42,
+  "received": 1720000000,
+  "retention_days": 30,
+  "payload": "<expanded Sample v2 profile JSON>",
+  "attachments": [
+    {
+      "name": "profile.perfetto",
+      "content_type": "application/x-perfetto-trace",
+      "stored_id": "<object store key of the raw .pftrace blob>"
+    }
+  ]
+}
+```
+
+The monolith later uses `stored_id` to fetch the raw trace back.
+
+## Monolith (getsentry/sentry)
+
+`process_profile_task` (in `src/sentry/profiles/task.py`) consumes the `profiles` topic.
+Because Relay already converted the trace to Sample v2, the task treats a Perfetto chunk
+like any other: deobfuscate, hand it to `vroomrs` to parse and normalize
+(`vroomrs.profile_chunk_from_json_str(...)`), compress and store it, and emit function
+metrics to Snuba.
+
+The Perfetto-specific step is the last one: for each attachment on the message the task
+persists a lightweight **`ProfileChunkAttachment`** row — `project_id`, `profiler_id`,
+`chunk_id`, `name`, `content_type`, and the `stored_id` object store key. The row exists so
+the raw trace can be downloaded by ID without exposing the `stored_id`.
+
+Flamegraphs themselves are served by `getsentry/vroom`, which reads the stored chunks and
+the Snuba-indexed metadata and merges several chunks into one flamegraph. The endpoint
+lives in the monolith and passes the request through.
+
+### Perfetto format dispatch (vroom / vroomrs)
+
+Older Android SDKs emit the legacy Android trace format tagged as a "faulty" `version=2`,
+and the pipeline historically keyed off the platform rather than the version. To
+distinguish legacy from Sample v2 chunks, `ProfileChunk` carries a dedicated `version`
+field, and both `vroom` and `vroomrs` now dispatch on it instead of the platform:
+
+- Version `""` or `2.android-trace` → legacy Android trace format.
+- Any other version → Sample v2.
+
+## Downloading a Perfetto profile
+
+The monolith exposes two feature-gated endpoints:
+
+- **List attachments** — `GET /organizations/{org}/profiling/chunk-attachments/`
+  (`sentry-api-0-organization-profiling-chunk-attachments`). Requires a `project` and
+  `profiler_id`; resolves the visible `chunk_id`s (same logic as the flamegraph) and returns
+  the matching `ProfileChunkAttachment` metadata.
+- **Download** — `GET /projects/{org}/{project}/profiling/chunks/{profiler_id}/{chunk_id}/attachments/{attachment_id}/?download`
+  (`sentry-api-0-project-profiling-chunk-attachment`). The `?download` param is required; it
+  streams the raw blob back from object store via the stored `stored_id`. Access requires
+  the org's configured attachments role, analogous to generic event attachments.
+
+In the flamegraph UI, a toolbar button (added for continuous profiles when the feature is
+enabled and at least one attachment exists) lists and provides a way to download these traces.
+
+## References
+
+- SDK: [sentry-java#5251](https://github.com/getsentry/sentry-java/pull/5251) — Android `ProfilingManager` (Perfetto) support
+- Relay: [#5659](https://github.com/getsentry/relay/pull/5659), [#5932](https://github.com/getsentry/relay/pull/5932), [#6099](https://github.com/getsentry/relay/pull/6099), [#6102](https://github.com/getsentry/relay/pull/6102) — Perfetto parsing, pipeline, and object-store routing
+- vroom: [#672](https://github.com/getsentry/vroom/pull/672) — version dispatch for Android trace profiles
+- vroomrs: [#93](https://github.com/getsentry/vroomrs/pull/93) — accept Android profiles in Sample v2 format
+- Monolith: [sentry#118029](https://github.com/getsentry/sentry/pull/118029) (chunk attachments + endpoints), [sentry#118071](https://github.com/getsentry/sentry/pull/118071) (flamegraph download button)
diff --git a/develop-docs/general/pipeline.md b/develop-docs/general/pipeline.md
new file mode 100644
index 00000000000..6cb0d87f696
--- /dev/null
+++ b/develop-docs/general/pipeline.md
@@ -0,0 +1,121 @@
+# Ingestion pipeline
+
+This document describes the path data takes from an SDK to a rendered view in Sentry. It
+covers the parts of different payload types, like errors, transactions, logs, replays and
+profile chunks.
+
+## Per data category
+
+Every payload takes the same four hops — SDK, Relay, a consumer in the monolith, and a read
+API — but the topics, processing tasks, and stores differ per category. The diagrams below
+show three of them; the hops themselves are described further down.
+
+### Errors
+
+```mermaid
+flowchart LR
+    SDK["SDK<br/>captures + batches"] -->|envelope| RELAY
+    RELAY["Relay<br/>authenticate, normalize,<br/>route"] -->|ingest-events| KAFKA[["Kafka"]]
+    RELAY -.->|attachments,<br/>minidumps| OS[("Object store")]
+    KAFKA --> TASK["save_event task"]
+    TASK --> SYM["Symbolicator<br/>symbolicate, deobfuscate"]
+    SYM --> TASK
+    TASK --> NS[("Nodestore<br/>full event body")]
+    TASK --> SNUBA[("Snuba<br/>searchable columns")]
+    TASK --> PG[("Postgres<br/>Group / GroupHash rows")]
+    NS --> READ["Read path<br/>monolith API"]
+    SNUBA --> READ
+    PG --> READ
+    OS --> READ
+```
+
+### Transactions
+
+```mermaid
+flowchart LR
+    SDK["SDK<br/>captures spans"] -->|envelope| RELAY
+    RELAY["Relay<br/>normalize, dynamic sampling,<br/>metric extraction"] -->|ingest-transactions| KAFKA[["Kafka"]]
+    KAFKA --> CONSUMER["Transaction consumer"]
+    CONSUMER --> SNUBA[("Snuba<br/>transactions + spans")]
+    CONSUMER --> NS[("Nodestore<br/>full transaction body")]
+    SNUBA --> READ["Read path<br/>monolith API"]
+    NS --> READ
+```
+
+### Profile chunks
+
+```mermaid
+flowchart LR
+    SDK["SDK<br/>captures profile chunks"] -->|envelope| RELAY
+    RELAY["Relay<br/>convert Perfetto → Sample v2"] -->|profiles| KAFKA[["Kafka"]]
+    RELAY -.->|raw .pftrace blob| OS[("Object store")]
+    KAFKA --> TASK["process_profile_task"]
+    TASK --> VRS["vroomrs<br/>parse + normalize"]
+    VRS --> OS
+    VRS --> SNUBA[("Snuba<br/>function metrics")]
+    TASK --> PG[("Postgres<br/>ProfileChunkAttachment rows")]
+    OS --> VROOM["vroom<br/>serve + merge flamegraphs"]
+    SNUBA --> VROOM
+    VROOM --> READ["Read path<br/>monolith API"]
+    PG --> READ
+```
+
+## The hops
+
+### 1. SDK
+
+The SDK captures data and wraps it in an [envelope](https://develop.sentry.dev/sdk/data-model/envelopes/):
+a JSON header followed by one or more items, each with its own header declaring a `type`,
+a `length`, and optionally a `content_type`. The envelope is POSTed to the project's
+`/api/{project_id}/envelope/` endpoint.
+
+The item `type` is what routes the payload through everything downstream, so adding a new
+kind of data means adding an item type, not a new endpoint. Item payloads are usually JSON;
+binary payloads are allowed and are preferable to base64-encoding a large blob into JSON.
+
+### 2. Relay
+
+[Relay](https://github.com/getsentry/relay) is Sentry's ingestion proxy — it sits between
+the SDK and the rest of the infrastructure and is the first service to inspect a payload.
+See the [Relay chapter in develop docs](https://develop.sentry.dev/ingestion/relay/) for
+the full picture.
+
+Relay authenticates the DSN, applies quotas and rate limits, filters and normalizes the
+payload, and forwards it. Two behaviours matter when designing a new payload type:
+
+- Relay may **convert** a payload into a different format before publishing it, so the
+  format the SDK sends and the format the backend consumes are not necessarily the same.
+  Whatever Relay publishes is the contract every downstream service depends on.
+- Relay runs in two modes. Only **processing mode** (the one Sentry operates) talks to
+  Kafka and the object store; a self-hosted Relay in proxy mode just forwards envelopes
+  upstream.
+
+Relay publishes to a **Kafka topic per data category**. Payloads too large to sit
+comfortably in a Kafka message are uploaded to the **object store** instead, and the
+message carries a reference to the stored blob rather than the bytes themselves. Event
+attachments (minidumps, screenshots, view hierarchies) work this way, and so does the raw
+`.pftrace` blob of a Perfetto profile chunk: Relay uploads the trace and puts only its
+`stored_id` object store key on the Kafka message.
+
+### 3. Consumers and processing
+
+Each topic is consumed by the monolith ([getsentry/sentry](https://github.com/getsentry/sentry)),
+which runs a processing task per message. This is where the work that needs Sentry-side
+state happens — symbolication and deobfuscation against uploaded debug files, enrichment,
+normalization, and quota accounting.
+
+A task typically writes to more than one store:
+
+- **Object store** — the payload itself, compressed. Cheap to keep, not queryable.
+- **Snuba** — the columns that need to be searched, aggregated, or listed.
+- **Postgres** — small metadata rows that the API needs to resolve a request, for example
+  a row per stored blob so it can be fetched by ID instead of by exposing its storage key.
+
+### 4. Read path
+
+The monolith serves the API endpoints. For some categories it does the work itself; for
+others it authorizes the request and proxies it to a dedicated service that owns the
+heavy read logic. Either way the endpoint is the public surface, and the storage keys and
+internal services stay behind it.
+
+See [feature/profiling/perfetto.md](../feature/profiling/perfetto.md) for a worked example.

From c5053ad346da88d8f09f4745ad6837d25818bcd1 Mon Sep 17 00:00:00 2001
From: arb <adam.brown@sentry.io>
Date: Wed, 12 Aug 2026 15:41:22 +0200
Subject: [PATCH 385/391] chore(android-sqlite): Remove experimental status
 from SentrySQLiteDriver (#5938)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Removes @ApiStatus.Experimental from SentrySQLiteDriver after reviewing production crash signal.

Crash review (Sentry sdk-crashes-java + Datadog SDK Crash Detection):

 - Only a handful of events (~10 over ~2 weeks) mention SentrySQLiteDriver / SentrySQLiteStatement. All are ordinary Android SQLite failures (disk I/O, full disk, read-only, can’t open) that pass through the wrapper — not instrumentation bugs.

 - No ANRs, NPEs, or “Failed to instrument SQLite” failures on the io.sentry.sqlite path.

 - Datadog Android crash rates for versions with the driver (8.45+) look healthy (~0.5–1.6 SDK crashes per 1K crashes excl. ANRs); no post-release spike attributable to the driver.

 - Higher-volume “sqlite” noise in crash dashboards is almost entirely the older SentrySupportSQLite* path (same false-positive pattern: customer DB errors with our frames as culprit).
---
 CHANGELOG.md                                              | 4 ++++
 sentry-android-sqlite/build.gradle.kts                    | 6 ------
 .../src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt  | 8 +++-----
 3 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d841fa4d866..50e013db548 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,10 @@
 
 - Make `ISpan.startChild` overloads with `SpanOptions` public ([#5927](https://github.com/getsentry/sentry-java/pull/5927))
 
+### Improvements
+
+- Remove `ApiStatus.Experimental` annotation from `SentrySQLiteDriver` ([#5938](https://github.com/getsentry/sentry-java/pull/5938))
+
 ### Fixes
 
 - Clear contexts when calling `Scope.clear()` ([#5902](https://github.com/getsentry/sentry-java/pull/5902))
diff --git a/sentry-android-sqlite/build.gradle.kts b/sentry-android-sqlite/build.gradle.kts
index 9cf09fd76fd..9637b91546a 100644
--- a/sentry-android-sqlite/build.gradle.kts
+++ b/sentry-android-sqlite/build.gradle.kts
@@ -53,10 +53,6 @@ android {
 
   buildFeatures { buildConfig = true }
 
-  // Needed b/c Kotlin 1.4.x would otherwise pull in an older version without the annotations we
-  // want.
-  configurations.all { resolutionStrategy.force(libs.jetbrains.annotations.get()) }
-
   androidComponents.beforeVariants {
     it.enable = !Config.Android.shouldSkipDebugVariant(it.buildType)
   }
@@ -75,14 +71,12 @@ dependencies {
   api(projects.sentry)
 
   compileOnly(libs.androidx.sqlite)
-  compileOnly(libs.jetbrains.annotations)
 
   implementation(kotlin(Config.kotlinStdLib, Config.kotlinStdLibVersionAndroid))
 
   // tests
   testImplementation(libs.androidx.sqlite)
   testImplementation(libs.kotlin.test.junit)
-  testImplementation(libs.androidx.test.ext.junit)
   testImplementation(libs.mockito.kotlin)
   testImplementation(libs.mockito.inline)
 }
diff --git a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
index 4a616ba3abe..28b661cd3e7 100644
--- a/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
+++ b/sentry-android-sqlite/src/main/java/io/sentry/sqlite/SentrySQLiteDriver.kt
@@ -3,9 +3,8 @@ package io.sentry.sqlite
 import androidx.sqlite.SQLiteConnection
 import androidx.sqlite.SQLiteDriver
 import io.sentry.ScopesAdapter
-import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.SentryLevel
-import org.jetbrains.annotations.ApiStatus
+import io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion
 
 /**
  * Wraps a [SQLiteDriver] and automatically adds spans for each SQL statement it executes.
@@ -23,16 +22,15 @@ import org.jetbrains.annotations.ApiStatus
  * ```
  *
  * If you're using the Sentry Android Gradle Plugin (SAGP) 6.13.0+, wrapping will be performed
- * automatically.
+ * automatically for Room.
  *
  * @param delegate The [SQLiteDriver] instance to delegate calls to.
  */
-@ApiStatus.Experimental
 public class SentrySQLiteDriver private constructor(private val delegate: SQLiteDriver) :
   SQLiteDriver {
 
   init {
-    SentryIntegrationPackageStorage.getInstance().addIntegration("SQLiteDriver")
+    addIntegrationToSdkVersion("SQLiteDriver")
   }
 
   @Suppress("INAPPLICABLE_JVM_NAME")

From dfa8aad298d1d85720491e3c43f9ef3bcb7e84d9 Mon Sep 17 00:00:00 2001
From: Alexander Dinauer <adinauer@users.noreply.github.com>
Date: Wed, 12 Aug 2026 16:20:16 +0200
Subject: [PATCH 386/391] feat(core): Add timestamped child spans to ISpan
 (#5929)

* feat(core): Add timestamped child spans to ISpan

Expose explicit start timestamps for nested spans and forward them through
core and OpenTelemetry span implementations. Use a default interface method
to preserve compatibility with external ISpan implementations.

Fixes #5896
Co-Authored-By: Claude <noreply@anthropic.com>

* changelog

---------

Co-authored-by: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  1 +
 .../api/sentry-opentelemetry-bootstrap.api    |  1 +
 .../build.gradle.kts                          |  1 +
 .../OtelStrongRefSpanWrapper.java             |  6 ++
 .../OtelStrongRefSpanWrapperTest.kt           | 26 ++++++++
 .../api/sentry-opentelemetry-core.api         |  1 +
 .../build.gradle.kts                          |  1 +
 .../sentry/opentelemetry/OtelSpanWrapper.java |  6 ++
 .../src/test/kotlin/OtelSpanWrapperTest.kt    | 60 +++++++++++++++++++
 sentry/api/sentry.api                         |  4 +-
 sentry/src/main/java/io/sentry/ISpan.java     | 14 +++++
 .../src/main/java/io/sentry/ITransaction.java | 12 ----
 sentry/src/main/java/io/sentry/NoOpSpan.java  |  6 ++
 sentry/src/main/java/io/sentry/Span.java      |  6 ++
 .../src/test/java/io/sentry/NoOpSpanTest.kt   |  6 ++
 sentry/src/test/java/io/sentry/SpanTest.kt    | 14 +++++
 16 files changed, 152 insertions(+), 13 deletions(-)
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/test/kotlin/io/sentry/opentelemetry/OtelStrongRefSpanWrapperTest.kt
 create mode 100644 sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelSpanWrapperTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 50e013db548..fcb5d4da67d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@
 
 ### Features
 
+- Allow child spans to use explicit start timestamps through `ISpan` ([#5929](https://github.com/getsentry/sentry-java/pull/5929))
 - Make `ISpan.startChild` overloads with `SpanOptions` public ([#5927](https://github.com/getsentry/sentry-java/pull/5927))
 
 ### Improvements
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/api/sentry-opentelemetry-bootstrap.api b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/api/sentry-opentelemetry-bootstrap.api
index ba43abdbec7..1f81e4324d4 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/api/sentry-opentelemetry-bootstrap.api
+++ b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/api/sentry-opentelemetry-bootstrap.api
@@ -85,6 +85,7 @@ public final class io/sentry/opentelemetry/OtelStrongRefSpanWrapper : io/sentry/
 	public fun startChild (Lio/sentry/SpanContext;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;)Lio/sentry/ISpan;
+	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
index b69ae1be7b4..3585aa40d4a 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/build.gradle.kts
@@ -28,6 +28,7 @@ dependencies {
   testImplementation(projects.sentryTestSupport)
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(libs.awaitility.kotlin)
+  testImplementation(libs.google.truth)
   testImplementation(libs.kotlin.test.junit)
   testImplementation(libs.mockito.kotlin)
 
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/main/java/io/sentry/opentelemetry/OtelStrongRefSpanWrapper.java b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/main/java/io/sentry/opentelemetry/OtelStrongRefSpanWrapper.java
index 995fe7f787b..907d71a278b 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/main/java/io/sentry/opentelemetry/OtelStrongRefSpanWrapper.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/main/java/io/sentry/opentelemetry/OtelStrongRefSpanWrapper.java
@@ -125,6 +125,12 @@ public void setTransactionName(@NotNull String name, @NotNull TransactionNameSou
     return delegate.startChild(spanContext, spanOptions);
   }
 
+  @Override
+  public @NotNull ISpan startChild(
+      @NotNull String operation, @Nullable String description, @Nullable SentryDate timestamp) {
+    return delegate.startChild(operation, description, timestamp);
+  }
+
   @Override
   public @NotNull ISpan startChild(
       @NotNull String operation,
diff --git a/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/test/kotlin/io/sentry/opentelemetry/OtelStrongRefSpanWrapperTest.kt b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/test/kotlin/io/sentry/opentelemetry/OtelStrongRefSpanWrapperTest.kt
new file mode 100644
index 00000000000..c8547d8220f
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-bootstrap/src/test/kotlin/io/sentry/opentelemetry/OtelStrongRefSpanWrapperTest.kt
@@ -0,0 +1,26 @@
+package io.sentry.opentelemetry
+
+import com.google.common.truth.Truth.assertThat
+import io.opentelemetry.api.trace.Span
+import io.sentry.ISpan
+import io.sentry.SentryLongDate
+import kotlin.test.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class OtelStrongRefSpanWrapperTest {
+  @Test
+  fun `startChild with timestamp forwards to delegate`() {
+    val delegate = mock<IOtelSpanWrapper>()
+    val wrapper = OtelStrongRefSpanWrapper(mock<Span>(), delegate)
+    val timestamp = SentryLongDate(1234)
+    val expectedChild = mock<ISpan>()
+    whenever(delegate.startChild("child-op", "description", timestamp)).thenReturn(expectedChild)
+
+    val child = wrapper.startChild("child-op", "description", timestamp)
+
+    verify(delegate).startChild("child-op", "description", timestamp)
+    assertThat(child).isSameInstanceAs(expectedChild)
+  }
+}
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/api/sentry-opentelemetry-core.api b/sentry-opentelemetry/sentry-opentelemetry-core/api/sentry-opentelemetry-core.api
index 847d69bca1b..3ed25d1a9cf 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/api/sentry-opentelemetry-core.api
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/api/sentry-opentelemetry-core.api
@@ -99,6 +99,7 @@ public final class io/sentry/opentelemetry/OtelSpanWrapper : io/sentry/opentelem
 	public fun startChild (Lio/sentry/SpanContext;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;)Lio/sentry/ISpan;
+	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts b/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
index 7c92b8a87a5..a252628c1a2 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/build.gradle.kts
@@ -38,6 +38,7 @@ dependencies {
   testImplementation(projects.sentryTestSupport)
   testImplementation(kotlin(Config.kotlinStdLib))
   testImplementation(libs.awaitility.kotlin)
+  testImplementation(libs.google.truth)
   testImplementation(libs.kotlin.test.junit)
   testImplementation(libs.mockito.kotlin)
 
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSpanWrapper.java b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSpanWrapper.java
index a72084ad67f..80da51f9db7 100644
--- a/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSpanWrapper.java
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/main/java/io/sentry/opentelemetry/OtelSpanWrapper.java
@@ -141,6 +141,12 @@ public OtelSpanWrapper(
     return childSpan;
   }
 
+  @Override
+  public @NotNull ISpan startChild(
+      @NotNull String operation, @Nullable String description, @Nullable SentryDate timestamp) {
+    return startChild(operation, description, timestamp, Instrumenter.SENTRY);
+  }
+
   @Override
   public @NotNull ISpan startChild(
       @NotNull String operation,
diff --git a/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelSpanWrapperTest.kt b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelSpanWrapperTest.kt
new file mode 100644
index 00000000000..98d3989aaaf
--- /dev/null
+++ b/sentry-opentelemetry/sentry-opentelemetry-core/src/test/kotlin/OtelSpanWrapperTest.kt
@@ -0,0 +1,60 @@
+package io.sentry.opentelemetry
+
+import com.google.common.truth.Truth.assertThat
+import io.opentelemetry.api.trace.SpanContext
+import io.opentelemetry.api.trace.TraceFlags
+import io.opentelemetry.api.trace.TraceState
+import io.opentelemetry.sdk.trace.ReadWriteSpan
+import io.sentry.IScopes
+import io.sentry.ISpan
+import io.sentry.ISpanFactory
+import io.sentry.Instrumenter
+import io.sentry.SentryLongDate
+import io.sentry.SentryOptions
+import io.sentry.SpanOptions
+import kotlin.test.Test
+import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
+import org.mockito.kotlin.eq
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class OtelSpanWrapperTest {
+  @Test
+  fun `startChild with timestamp forwards timestamp and Sentry instrumenter`() {
+    val otelSpan = mock<ReadWriteSpan>()
+    whenever(otelSpan.spanContext)
+      .thenReturn(
+        SpanContext.create(
+          "2722d9f6ec019ade60c776169d9a8904",
+          "cedf5b7571cb4972",
+          TraceFlags.getSampled(),
+          TraceState.getDefault(),
+        )
+      )
+    whenever(otelSpan.name).thenReturn("parent")
+
+    val spanFactory = mock<ISpanFactory>()
+    val options = SentryOptions().apply { this.spanFactory = spanFactory }
+    val scopes = mock<IScopes>()
+    whenever(scopes.options).thenReturn(options)
+
+    val parent = OtelSpanWrapper(otelSpan, scopes, SentryLongDate(0), null, null, null, null)
+    val expectedChild = mock<ISpan>()
+    whenever(spanFactory.createSpan(eq(scopes), any(), any(), eq(parent))).thenReturn(expectedChild)
+    val timestamp = SentryLongDate(1234)
+
+    val child = parent.startChild("child-op", "description", timestamp)
+
+    val spanOptions = argumentCaptor<SpanOptions>()
+    val spanContext = argumentCaptor<io.sentry.SpanContext>()
+    verify(spanFactory)
+      .createSpan(eq(scopes), spanOptions.capture(), spanContext.capture(), eq(parent))
+    assertThat(child).isSameInstanceAs(expectedChild)
+    assertThat(spanOptions.firstValue.startTimestamp).isSameInstanceAs(timestamp)
+    assertThat(spanContext.firstValue.operation).isEqualTo("child-op")
+    assertThat(spanContext.firstValue.description).isEqualTo("description")
+    assertThat(spanContext.firstValue.instrumenter).isEqualTo(Instrumenter.SENTRY)
+  }
+}
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 774bfd90bf3..54729fdb12b 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -1197,6 +1197,7 @@ public abstract interface class io/sentry/ISpan {
 	public abstract fun startChild (Lio/sentry/SpanContext;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public abstract fun startChild (Ljava/lang/String;)Lio/sentry/ISpan;
 	public abstract fun startChild (Ljava/lang/String;Ljava/lang/String;)Lio/sentry/ISpan;
+	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;)Lio/sentry/ISpan;
 	public abstract fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;)Lio/sentry/ISpan;
 	public abstract fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public abstract fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
@@ -1223,7 +1224,6 @@ public abstract interface class io/sentry/ITransaction : io/sentry/ISpan {
 	public abstract fun scheduleFinish ()V
 	public abstract fun setName (Ljava/lang/String;)V
 	public abstract fun setName (Ljava/lang/String;Lio/sentry/protocol/TransactionNameSource;)V
-	public abstract fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;)Lio/sentry/ISpan;
 }
 
 public abstract interface class io/sentry/ITransactionProfiler {
@@ -1939,6 +1939,7 @@ public final class io/sentry/NoOpSpan : io/sentry/ISpan {
 	public fun startChild (Lio/sentry/SpanContext;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;)Lio/sentry/ISpan;
+	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
@@ -4378,6 +4379,7 @@ public final class io/sentry/Span : io/sentry/ISpan {
 	public fun startChild (Lio/sentry/SpanContext;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;)Lio/sentry/ISpan;
+	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SentryDate;Lio/sentry/Instrumenter;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
 	public fun startChild (Ljava/lang/String;Ljava/lang/String;Lio/sentry/SpanOptions;)Lio/sentry/ISpan;
diff --git a/sentry/src/main/java/io/sentry/ISpan.java b/sentry/src/main/java/io/sentry/ISpan.java
index 7f54b7e58a2..9c55cdc3201 100644
--- a/sentry/src/main/java/io/sentry/ISpan.java
+++ b/sentry/src/main/java/io/sentry/ISpan.java
@@ -66,6 +66,20 @@ ISpan startChild(
   @NotNull
   ISpan startChild(@NotNull String operation, @Nullable String description);
 
+  /**
+   * Starts a child Span.
+   *
+   * @param operation - new span operation name
+   * @param description - the span description
+   * @param timestamp - the start timestamp of the span
+   * @return a new transaction span
+   */
+  @NotNull
+  default ISpan startChild(
+      @NotNull String operation, @Nullable String description, @Nullable SentryDate timestamp) {
+    return startChild(operation, description, timestamp, Instrumenter.SENTRY);
+  }
+
   /**
    * Returns the trace information that could be sent as a sentry-trace header.
    *
diff --git a/sentry/src/main/java/io/sentry/ITransaction.java b/sentry/src/main/java/io/sentry/ITransaction.java
index 403b21187b7..f6902502b97 100644
--- a/sentry/src/main/java/io/sentry/ITransaction.java
+++ b/sentry/src/main/java/io/sentry/ITransaction.java
@@ -40,18 +40,6 @@ public interface ITransaction extends ISpan {
   @TestOnly
   List<Span> getSpans();
 
-  /**
-   * Starts a child Span.
-   *
-   * @param operation - new span operation name
-   * @param description - the span description
-   * @param timestamp - the start timestamp of the span
-   * @return a new transaction span
-   */
-  @NotNull
-  ISpan startChild(
-      @NotNull String operation, @Nullable String description, @Nullable SentryDate timestamp);
-
   /**
    * Returns if the profile of a transaction is sampled.
    *
diff --git a/sentry/src/main/java/io/sentry/NoOpSpan.java b/sentry/src/main/java/io/sentry/NoOpSpan.java
index eff9f4f875c..6d9b373200f 100644
--- a/sentry/src/main/java/io/sentry/NoOpSpan.java
+++ b/sentry/src/main/java/io/sentry/NoOpSpan.java
@@ -58,6 +58,12 @@ public static NoOpSpan getInstance() {
     return NoOpSpan.getInstance();
   }
 
+  @Override
+  public @NotNull ISpan startChild(
+      @NotNull String operation, @Nullable String description, @Nullable SentryDate timestamp) {
+    return NoOpSpan.getInstance();
+  }
+
   @Override
   public @NotNull SentryTraceHeader toSentryTrace() {
     return new SentryTraceHeader(SentryId.EMPTY_ID, SpanId.EMPTY_ID, false);
diff --git a/sentry/src/main/java/io/sentry/Span.java b/sentry/src/main/java/io/sentry/Span.java
index 59a925d7a0a..7ee7eed1900 100644
--- a/sentry/src/main/java/io/sentry/Span.java
+++ b/sentry/src/main/java/io/sentry/Span.java
@@ -118,6 +118,12 @@ public Span(
         context.getSpanId(), operation, description, timestamp, instrumenter, spanOptions);
   }
 
+  @Override
+  public @NotNull ISpan startChild(
+      @NotNull String operation, @Nullable String description, @Nullable SentryDate timestamp) {
+    return startChild(operation, description, timestamp, Instrumenter.SENTRY);
+  }
+
   @Override
   public @NotNull ISpan startChild(
       final @NotNull String operation, final @Nullable String description) {
diff --git a/sentry/src/test/java/io/sentry/NoOpSpanTest.kt b/sentry/src/test/java/io/sentry/NoOpSpanTest.kt
index 78e1ada0b24..0b3c24fc055 100644
--- a/sentry/src/test/java/io/sentry/NoOpSpanTest.kt
+++ b/sentry/src/test/java/io/sentry/NoOpSpanTest.kt
@@ -1,5 +1,6 @@
 package io.sentry
 
+import com.google.common.truth.Truth.assertThat
 import kotlin.test.Test
 import kotlin.test.assertFalse
 import kotlin.test.assertIs
@@ -15,6 +16,11 @@ class NoOpSpanTest {
     assertNotNull(span.startChild("op", "desc"))
   }
 
+  @Test
+  fun `startChild with timestamp returns no-op span`() {
+    assertThat(span.startChild("op", "desc", SentryLongDate(1234))).isSameInstanceAs(span)
+  }
+
   @Test
   fun `getSpanContext does not return null`() {
     assertNotNull(span.spanContext)
diff --git a/sentry/src/test/java/io/sentry/SpanTest.kt b/sentry/src/test/java/io/sentry/SpanTest.kt
index cab10b80a9a..b61e12ad87f 100644
--- a/sentry/src/test/java/io/sentry/SpanTest.kt
+++ b/sentry/src/test/java/io/sentry/SpanTest.kt
@@ -1,5 +1,6 @@
 package io.sentry
 
+import com.google.common.truth.Truth.assertThat
 import io.sentry.protocol.SentryId
 import io.sentry.test.injectForField
 import kotlin.test.Test
@@ -94,6 +95,19 @@ class SpanTest {
     assertEquals("description", child.description)
   }
 
+  @Test
+  fun `starting a child with timestamp uses exact timestamp`() {
+    val parent: ISpan = fixture.getSut()
+    val timestamp = SentryLongDate(1234)
+
+    val child = parent.startChild("child-op", "description", timestamp) as Span
+
+    assertThat(child.parentSpanId).isEqualTo(parent.spanContext.spanId)
+    assertThat(child.operation).isEqualTo("child-op")
+    assertThat(child.description).isEqualTo("description")
+    assertThat(child.startDate).isSameInstanceAs(timestamp)
+  }
+
   @Test
   fun `converts to Sentry trace header`() {
     val traceId = SentryId()

From e0a36f0733c874ccf1ede15c0ff26a9fc0cf926b Mon Sep 17 00:00:00 2001
From: romtsn <4999776+romtsn@users.noreply.github.com>
Date: Wed, 12 Aug 2026 15:36:28 +0000
Subject: [PATCH 387/391] release: 8.53.0

---
 CHANGELOG.md      | 2 +-
 gradle.properties | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fcb5d4da67d..247a5e96d31 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,6 @@
 # Changelog
 
-## Unreleased
+## 8.53.0
 
 ### Features
 
diff --git a/gradle.properties b/gradle.properties
index e1f7ecae6dc..e9bfc0e8156 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -16,7 +16,7 @@ android.newDsl=false
 android.experimental.lint.version=9.2.1
 
 # Release information
-versionName=8.52.0
+versionName=8.53.0
 
 # Override the SDK name on native crashes on Android
 sentryAndroidSdkName=sentry.native.android

From 43777a5a3d79e34f02f67a79245e5b609bdc0682 Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Thu, 13 Aug 2026 12:47:06 +0200
Subject: [PATCH 388/391] docs(agents): Forbid introducing new catch Throwable
 (#5944)

* docs(agents): Forbid introducing new catch Throwable

Add an "Exception Handling" section to AGENTS.md telling agents to catch
the narrowest exception type the guarded code can throw, and to never add
a new catch (Throwable). The repo already has ~355 such catches in main
sources; they are legacy and should not be read as a precedent.

A broad catch swallows OutOfMemoryError, StackOverflowError, ThreadDeath
and LinkageError, and hides bugs in our own code behind a log line. The
"never crash the host app" requirement is what usually motivates these
catches, so the section points at ExceptionUtils.rethrowIfFatal as the
way to satisfy it, and calls out the two cases that need care: probing an
optional compileOnly dependency via a LinkageError subclass, and not
swallowing InterruptedException.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

* docs(agents): Drop the two related cases from Exception Handling

The LinkageError and InterruptedException notes were detail the core rule
does not need.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>
---
 AGENTS.md | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/AGENTS.md b/AGENTS.md
index f785961eceb..fd1fced0df6 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -154,6 +154,33 @@ The repository is organized into multiple modules:
 - **Formatting**: Enforced via Spotless - always run `./gradlew spotlessApply` before committing
 - **API Compatibility**: Binary compatibility is enforced - run `./gradlew apiDump` after API changes
 
+### Exception Handling
+
+**Never introduce a new `catch (Throwable)`.** Catch the narrowest type the guarded code can
+actually throw. The repository still contains many pre-existing broad catches; they are legacy,
+not a precedent to follow.
+
+A broad catch swallows `OutOfMemoryError`, `StackOverflowError`, `ThreadDeath` and `LinkageError` —
+conditions the JVM/ART cannot recover from and that leave the process in an undefined state — and
+it hides real bugs in our own code behind a log line.
+
+"The SDK must never crash the host application" is not a reason to catch `Throwable`. That goal is
+served by `io.sentry.util.ExceptionUtils.rethrowIfFatal`, which lets the non-recoverable throwables
+through while leaving everything else for the caller to log or ignore:
+
+```java
+try {
+  doSomethingRisky();
+} catch (Throwable t) {
+  ExceptionUtils.rethrowIfFatal(t);
+  options.getLogger().log(SentryLevel.ERROR, "Failed to do something risky", t);
+}
+```
+
+Apply that pattern only where a broad catch is genuinely unavoidable — an entry point that runs
+arbitrary user code or third-party callbacks. Everywhere else, name the exception types. Say in the
+PR description why the broad catch is necessary.
+
 ### Testing Requirements
 - Write comprehensive unit tests for new features
 - Android modules require both unit tests and instrumented tests where applicable

From d8829dbe9f2fa5d7dd32c5b1eee3d42edc4c35a1 Mon Sep 17 00:00:00 2001
From: Markus Hintersteiner <markus.hintersteiner@sentry.io>
Date: Thu, 13 Aug 2026 20:40:07 +0200
Subject: [PATCH 389/391] feat(feedback): Support runtime enable/disable of
 shake-to-report (#5827)

---
 CHANGELOG.md                                  |   1 +
 .../api/sentry-android-core.api               |   7 +-
 .../core/FeedbackShakeIntegration.java        | 268 ++++++++++-----
 .../android/core/SentryUserFeedbackForm.java  |  90 ++++-
 .../core/FeedbackShakeIntegrationTest.kt      | 324 ++++++++++++++++++
 .../core/SentryUserFeedbackFormTest.kt        |  70 ++++
 .../io/sentry/samples/android/MainActivity.kt |  20 +-
 sentry/api/sentry.api                         |  14 +
 .../src/main/java/io/sentry/FeedbackApi.java  |  15 +
 .../src/main/java/io/sentry/IFeedbackApi.java |  27 ++
 .../main/java/io/sentry/NoOpFeedbackApi.java  |  11 +
 .../java/io/sentry/SentryFeedbackOptions.java |  37 +-
 .../main/java/io/sentry/SentryOptions.java    |  18 +-
 .../test/java/io/sentry/FeedbackApiTest.kt    |  47 +++
 .../io/sentry/SentryFeedbackOptionsTest.kt    |   6 +-
 .../test/java/io/sentry/SentryOptionsTest.kt  |  12 +
 16 files changed, 862 insertions(+), 105 deletions(-)
 create mode 100644 sentry/src/test/java/io/sentry/FeedbackApiTest.kt

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 247a5e96d31..83df10a9871 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,7 @@
 
 - Allow child spans to use explicit start timestamps through `ISpan` ([#5929](https://github.com/getsentry/sentry-java/pull/5929))
 - Make `ISpan.startChild` overloads with `SpanOptions` public ([#5927](https://github.com/getsentry/sentry-java/pull/5927))
+- Add `Sentry.feedback().enableOnShake()`, `Sentry.feedback().disableOnShake()`, and `Sentry.feedback().isOnShakeEnabled()` to toggle and query shake-to-report at runtime ([#5827](https://github.com/getsentry/sentry-java/pull/5827))
 
 ### Improvements
 
diff --git a/sentry-android-core/api/sentry-android-core.api b/sentry-android-core/api/sentry-android-core.api
index da80a74e32c..65bf072f0a0 100644
--- a/sentry-android-core/api/sentry-android-core.api
+++ b/sentry-android-core/api/sentry-android-core.api
@@ -293,9 +293,12 @@ public abstract class io/sentry/android/core/EnvelopeFileObserverIntegration : i
 	public final fun register (Lio/sentry/IScopes;Lio/sentry/SentryOptions;)V
 }
 
-public final class io/sentry/android/core/FeedbackShakeIntegration : android/app/Application$ActivityLifecycleCallbacks, io/sentry/Integration, java/io/Closeable {
+public final class io/sentry/android/core/FeedbackShakeIntegration : android/app/Application$ActivityLifecycleCallbacks, io/sentry/Integration, io/sentry/SentryFeedbackOptions$IShakeController, java/io/Closeable {
 	public fun <init> (Landroid/app/Application;)V
 	public fun close ()V
+	public fun disableOnShake ()V
+	public fun enableOnShake ()V
+	public fun isOnShakeEnabled ()Z
 	public fun onActivityCreated (Landroid/app/Activity;Landroid/os/Bundle;)V
 	public fun onActivityDestroyed (Landroid/app/Activity;)V
 	public fun onActivityPaused (Landroid/app/Activity;)V
@@ -573,7 +576,9 @@ public abstract interface class io/sentry/android/core/SentryUserFeedbackDialog$
 
 public class io/sentry/android/core/SentryUserFeedbackForm : android/app/AlertDialog {
 	protected fun onCreate (Landroid/os/Bundle;)V
+	public fun onDetachedFromWindow ()V
 	protected fun onStart ()V
+	protected fun onStop ()V
 	public fun setCancelable (Z)V
 	public fun setOnDismissListener (Landroid/content/DialogInterface$OnDismissListener;)V
 	public fun show ()V
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java b/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
index b059b0104da..4405cd19309 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/FeedbackShakeIntegration.java
@@ -4,31 +4,54 @@
 
 import android.app.Activity;
 import android.app.Application;
+import android.app.Dialog;
 import android.os.Bundle;
 import io.sentry.IScopes;
 import io.sentry.Integration;
+import io.sentry.SentryFeedbackOptions;
 import io.sentry.SentryLevel;
 import io.sentry.SentryOptions;
 import io.sentry.util.Objects;
 import java.io.Closeable;
 import java.io.IOException;
 import java.lang.ref.WeakReference;
+import java.util.concurrent.CopyOnWriteArrayList;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
 
 /**
- * Detects shake gestures and shows the user feedback dialog when a shake is detected. Only active
- * when {@link io.sentry.SentryFeedbackOptions#isUseShakeGesture()} returns {@code true}.
+ * Detects shake gestures and shows the user feedback dialog when a shake is detected. {@link
+ * io.sentry.SentryFeedbackOptions#isUseShakeGesture()} determines the initial state; it can be
+ * toggled at runtime via {@code Sentry.feedback().enableOnShake()} and {@code
+ * Sentry.feedback().disableOnShake()}.
+ *
+ * <p>Shake detection is scoped to the resumed activity: a dialog belongs to the window of the
+ * activity that created it, so it can only ever be visible while that activity is resumed. Dialogs
+ * report themselves via {@link #onDialogVisible(Activity, Dialog)} / {@link #onDialogGone(Dialog)}
+ * and detection is then suppressed for the activity hosting them, which keeps a shake from stacking
+ * a second dialog on top of a visible one without letting a dialog on a backgrounded activity
+ * suppress detection elsewhere.
  */
 public final class FeedbackShakeIntegration
-    implements Integration, Closeable, Application.ActivityLifecycleCallbacks {
+    implements Integration,
+        Closeable,
+        Application.ActivityLifecycleCallbacks,
+        SentryFeedbackOptions.IShakeController {
 
   private final @NotNull Application application;
   private final @NotNull SentryShakeDetector shakeDetector;
   private @Nullable SentryAndroidOptions options;
+  private volatile boolean enabled = false;
   private volatile @Nullable WeakReference<Activity> currentActivityRef;
-  private volatile boolean isDialogShowing = false;
-  private volatile @Nullable Runnable previousOnFormClose;
+
+  /**
+   * The feedback dialogs that are currently visible, together with the activity hosting them. More
+   * than one can be visible at a time, e.g. when the app calls {@code Sentry.feedback().show()}
+   * while another dialog is already showing.
+   */
+  private final @NotNull CopyOnWriteArrayList<VisibleDialog> visibleDialogs =
+      new CopyOnWriteArrayList<>();
 
   public FeedbackShakeIntegration(final @NotNull Application application) {
     this.application = Objects.requireNonNull(application, "Application is required");
@@ -46,13 +69,25 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
 
     final @NotNull SentryAndroidOptions options = this.options;
 
-    if (!options.getFeedbackOptions().isUseShakeGesture()) {
+    // Always expose the runtime toggle, even when the option starts out disabled.
+    options.getFeedbackOptions().setShakeController(this);
+
+    if (options.getFeedbackOptions().isUseShakeGesture()) {
+      enableOnShake();
+    }
+  }
+
+  @Override
+  public synchronized void enableOnShake() {
+    final @Nullable SentryAndroidOptions options = this.options;
+    if (enabled || options == null) {
       return;
     }
+    enabled = true;
 
-    // Re-arm the detector in case this integration is being re-registered after a previous close()
-    // (e.g. a second Sentry.init reusing the same options), otherwise the closed latch would keep
-    // shake detection off permanently.
+    // Re-arm the detector in case it was closed before, either by disableOnShake() or by a previous
+    // close() (e.g. a second Sentry.init reusing the same options), otherwise the closed latch
+    // would keep shake detection off permanently.
     shakeDetector.reopen();
 
     // Resolving the accelerometer is the most expensive part of init (the first SensorManager
@@ -72,7 +107,7 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
     application.registerActivityLifecycleCallbacks(this);
     options.getLogger().log(SentryLevel.DEBUG, "FeedbackShakeIntegration installed.");
 
-    // In case of a deferred init, hook into any already-resumed activity
+    // In case of a deferred init or runtime enable, hook into any already-resumed activity
     final @Nullable Activity activity = CurrentActivityHolder.getInstance().getActivity();
     if (activity != null) {
       currentActivityRef = new WeakReference<>(activity);
@@ -81,34 +116,111 @@ public void register(final @NotNull IScopes scopes, final @NotNull SentryOptions
   }
 
   @Override
-  public void close() throws IOException {
+  public synchronized void disableOnShake() {
+    if (!enabled) {
+      return;
+    }
+    enabled = false;
+
     application.unregisterActivityLifecycleCallbacks(this);
     shakeDetector.close();
-    // Restore onFormClose if a dialog is still showing, since lifecycle callbacks
-    // are now unregistered and onActivityDestroyed cleanup won't fire.
-    if (isDialogShowing) {
-      isDialogShowing = false;
-      if (options != null) {
-        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
-      }
-      previousOnFormClose = null;
-    }
     currentActivityRef = null;
   }
 
   @Override
-  public void onActivityResumed(final @NotNull Activity activity) {
-    // If a dialog is showing on a different activity (e.g. user navigated via notification),
-    // clean up since the dialog's host activity is going away and onActivityDestroyed
-    // won't match currentActivity anymore.
-    final @Nullable Activity current = currentActivityRef != null ? currentActivityRef.get() : null;
-    if (isDialogShowing && current != null && current != activity) {
-      isDialogShowing = false;
-      if (options != null) {
-        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
+  public boolean isOnShakeEnabled() {
+    return enabled;
+  }
+
+  /**
+   * Reports a feedback dialog as visible on {@code host}. Shake detection is suppressed for that
+   * activity until the dialog reports back via {@link #onDialogGone(Dialog)}, so a shake can never
+   * stack a second dialog on top of a visible one — no matter how the visible one was opened.
+   */
+  void onDialogVisible(final @NotNull Activity host, final @NotNull Dialog dialog) {
+    visibleDialogs.add(new VisibleDialog(host, dialog));
+    stopShakeDetection();
+  }
+
+  /** Reports a feedback dialog as no longer visible. Safe to call more than once per dialog. */
+  void onDialogGone(final @NotNull Dialog dialog) {
+    if (!removeDialog(dialog)) {
+      return;
+    }
+    final @Nullable WeakReference<Activity> currentRef = currentActivityRef;
+    final @Nullable Activity current = currentRef == null ? null : currentRef.get();
+    if (enabled && current != null) {
+      startShakeDetection(current);
+    }
+  }
+
+  private boolean removeDialog(final @NotNull Dialog dialog) {
+    boolean removed = false;
+    for (final @NotNull VisibleDialog visibleDialog : visibleDialogs) {
+      // Drop entries whose dialog was collected without reporting back, so they can't suppress
+      // detection forever.
+      final @Nullable Dialog trackedDialog = visibleDialog.dialogRef.get();
+      if (trackedDialog == dialog) {
+        removed = visibleDialogs.remove(visibleDialog) || removed;
+      } else if (trackedDialog == null) {
+        visibleDialogs.remove(visibleDialog);
       }
-      previousOnFormClose = null;
     }
+    return removed;
+  }
+
+  private boolean hasDialogOn(final @NotNull Activity activity) {
+    for (final @NotNull VisibleDialog visibleDialog : visibleDialogs) {
+      if (visibleDialog.dialogRef.get() != null && visibleDialog.activityRef.get() == activity) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @TestOnly
+  @Nullable
+  Activity getDialogActivity() {
+    for (final @NotNull VisibleDialog visibleDialog : visibleDialogs) {
+      if (visibleDialog.dialogRef.get() != null) {
+        return visibleDialog.activityRef.get();
+      }
+    }
+    return null;
+  }
+
+  /** Creates the dialog shown on shake. Replaceable in tests to simulate a failing show(). */
+  interface DialogFactory {
+    @NotNull
+    Dialog create(final @NotNull Activity activity);
+  }
+
+  private @NotNull DialogFactory dialogFactory =
+      activity -> new SentryUserFeedbackForm.Builder(activity).create();
+
+  @TestOnly
+  void setDialogFactory(final @NotNull DialogFactory dialogFactory) {
+    this.dialogFactory = dialogFactory;
+  }
+
+  private static final class VisibleDialog {
+    private final @NotNull WeakReference<Activity> activityRef;
+    private final @NotNull WeakReference<Dialog> dialogRef;
+
+    VisibleDialog(final @NotNull Activity activity, final @NotNull Dialog dialog) {
+      this.activityRef = new WeakReference<>(activity);
+      this.dialogRef = new WeakReference<>(dialog);
+    }
+  }
+
+  @Override
+  public void close() throws IOException {
+    disableOnShake();
+    visibleDialogs.clear();
+  }
+
+  @Override
+  public void onActivityResumed(final @NotNull Activity activity) {
     currentActivityRef = new WeakReference<>(activity);
     startShakeDetection(activity);
   }
@@ -118,16 +230,11 @@ public void onActivityPaused(final @NotNull Activity activity) {
     // Only stop if this is the activity we're tracking. When transitioning between
     // activities, B.onResume may fire before A.onPause — stopping unconditionally
     // would kill shake detection for the new activity.
-    final @Nullable Activity current = currentActivityRef != null ? currentActivityRef.get() : null;
+    final @Nullable WeakReference<Activity> currentRef = currentActivityRef;
+    final @Nullable Activity current = currentRef != null ? currentRef.get() : null;
     if (activity == current) {
       stopShakeDetection();
-      // Keep currentActivityRef set when a dialog is showing so onActivityDestroyed
-      // can still match and clean up. Otherwise the cleanup condition
-      // (activity == current) would always be false since onPause fires
-      // before onDestroy.
-      if (!isDialogShowing) {
-        currentActivityRef = null;
-      }
+      currentActivityRef = null;
     }
   }
 
@@ -146,19 +253,7 @@ public void onActivitySaveInstanceState(
       final @NotNull Activity activity, final @NotNull Bundle outState) {}
 
   @Override
-  public void onActivityDestroyed(final @NotNull Activity activity) {
-    // Only reset if this is the activity that hosts the dialog — the dialog cannot
-    // outlive its host activity being destroyed.
-    final @Nullable Activity current = currentActivityRef != null ? currentActivityRef.get() : null;
-    if (isDialogShowing && activity == current) {
-      isDialogShowing = false;
-      currentActivityRef = null;
-      if (options != null) {
-        options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
-      }
-      previousOnFormClose = null;
-    }
-  }
+  public void onActivityDestroyed(final @NotNull Activity activity) {}
 
   private void startShakeDetection(final @NotNull Activity activity) {
     if (options == null) {
@@ -166,47 +261,50 @@ private void startShakeDetection(final @NotNull Activity activity) {
     }
     // Stop any existing detection (e.g. when transitioning between activities)
     stopShakeDetection();
+    // A dialog is already visible here, so a shake could only stack a second one on top of it.
+    // The dialog has no detector of its own in this case: SentryUserFeedbackForm only starts one
+    // while shake-to-report is globally disabled, which is exactly when this integration is not
+    // detecting either.
+    if (hasDialogOn(activity)) {
+      return;
+    }
     shakeDetector.start(
         activity,
         () -> {
           final @Nullable WeakReference<Activity> ref = currentActivityRef;
           final Activity active = ref != null ? ref.get() : null;
           final Boolean inBackground = AppState.getInstance().isInBackground();
-          if (active != null
-              && options != null
-              && !isDialogShowing
-              && !Boolean.TRUE.equals(inBackground)) {
-            active.runOnUiThread(
-                () -> {
-                  if (isDialogShowing || active.isFinishing() || active.isDestroyed()) {
-                    return;
-                  }
-                  try {
-                    isDialogShowing = true;
-                    final Runnable captured = options.getFeedbackOptions().getOnFormClose();
-                    previousOnFormClose = captured;
-                    options
-                        .getFeedbackOptions()
-                        .setOnFormClose(
-                            () -> {
-                              isDialogShowing = false;
-                              options.getFeedbackOptions().setOnFormClose(captured);
-                              if (captured != null) {
-                                captured.run();
-                              }
-                              previousOnFormClose = null;
-                            });
-                    new SentryUserFeedbackForm.Builder(active).create().show();
-                  } catch (Throwable e) {
-                    isDialogShowing = false;
-                    options.getFeedbackOptions().setOnFormClose(previousOnFormClose);
-                    previousOnFormClose = null;
-                    options
-                        .getLogger()
-                        .log(SentryLevel.ERROR, "Failed to show feedback dialog on shake.", e);
-                  }
-                });
+          if (active == null
+              || options == null
+              || !enabled
+              || hasDialogOn(active)
+              || Boolean.TRUE.equals(inBackground)) {
+            return;
           }
+          active.runOnUiThread(
+              () -> {
+                // Re-check on the main thread: shake-to-report may have been disabled, or an
+                // earlier queued shake may have shown a dialog in the meantime (the dialog reports
+                // itself synchronously in onStart).
+                if (!enabled
+                    || hasDialogOn(active)
+                    || active.isFinishing()
+                    || active.isDestroyed()) {
+                  return;
+                }
+                @Nullable Dialog dialog = null;
+                try {
+                  dialog = dialogFactory.create(active);
+                  dialog.show();
+                } catch (Throwable e) {
+                  if (dialog != null) {
+                    onDialogGone(dialog);
+                  }
+                  options
+                      .getLogger()
+                      .log(SentryLevel.ERROR, "Failed to show feedback dialog on shake.", e);
+                }
+              });
         });
   }
 
diff --git a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
index 43500d50ebc..01d4546d877 100644
--- a/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
+++ b/sentry-android-core/src/main/java/io/sentry/android/core/SentryUserFeedbackForm.java
@@ -60,9 +60,12 @@ public class SentryUserFeedbackForm extends AlertDialog {
   }
 
   private void maybeStartShakeDetection(final @NotNull Context context) {
+    // Only start shake detection if it's enabled within the options,
+    // and not already running globally
     final @NotNull SentryFeedbackOptions globalFeedbackOptions =
         Sentry.getCurrentScopes().getOptions().getFeedbackOptions();
-    if (!resolvedFeedbackOptions.isUseShakeGesture() || globalFeedbackOptions.isUseShakeGesture()) {
+    if (!resolvedFeedbackOptions.isUseShakeGesture()
+        || globalFeedbackOptions.getShakeController().isOnShakeEnabled()) {
       return;
     }
     final @Nullable Activity activity = getActivity(context);
@@ -95,6 +98,15 @@ private void stopShakeDetection() {
   private @NotNull SentryShakeDetector.Listener shakeListener(
       final @NotNull WeakReference<Activity> activityRef) {
     return () -> {
+      // If shake-to-report got enabled globally in the meantime, FeedbackShakeIntegration
+      // reacts to the same shake — don't show a second dialog for it.
+      if (Sentry.getCurrentScopes()
+          .getOptions()
+          .getFeedbackOptions()
+          .getShakeController()
+          .isOnShakeEnabled()) {
+        return;
+      }
       final @Nullable Activity active = activityRef.get();
       if (active != null && !active.isFinishing() && !active.isDestroyed()) {
         active.runOnUiThread(
@@ -284,13 +296,27 @@ protected void onCreate(Bundle savedInstanceState) {
             final @Nullable SentryFeedbackOptions.SentryFeedbackCallback onSubmitSuccess =
                 feedbackOptions.getOnSubmitSuccess();
             if (onSubmitSuccess != null) {
-              onSubmitSuccess.call(feedback);
+              try {
+                onSubmitSuccess.call(feedback);
+              } catch (Exception e) {
+                Sentry.getCurrentScopes()
+                    .getOptions()
+                    .getLogger()
+                    .log(SentryLevel.ERROR, "onSubmitSuccess callback threw an exception.", e);
+              }
             }
           } else {
             final @Nullable SentryFeedbackOptions.SentryFeedbackCallback onSubmitError =
                 feedbackOptions.getOnSubmitError();
             if (onSubmitError != null) {
-              onSubmitError.call(feedback);
+              try {
+                onSubmitError.call(feedback);
+              } catch (Exception e) {
+                Sentry.getCurrentScopes()
+                    .getOptions()
+                    .getLogger()
+                    .log(SentryLevel.ERROR, "onSubmitError callback threw an exception.", e);
+              }
             }
           }
           cancel();
@@ -310,7 +336,15 @@ public void setOnDismissListener(final @Nullable OnDismissListener listener) {
     if (onFormClose != null) {
       super.setOnDismissListener(
           dialog -> {
-            onFormClose.run();
+            // User-provided callback: a crash in it must not take down the app or skip the
+            // cleanup and the user's own dismiss listener below
+            try {
+              onFormClose.run();
+            } catch (Exception e) {
+              options
+                  .getLogger()
+                  .log(SentryLevel.ERROR, "onFormClose callback threw an exception.", e);
+            }
             currentReplayId = null;
             if (delegate != null) {
               delegate.onDismiss(dialog);
@@ -324,7 +358,7 @@ public void setOnDismissListener(final @Nullable OnDismissListener listener) {
   @Override
   protected void onStart() {
     super.onStart();
-    // Clear the message field so subsequent show() calls start with a fresh form
+    // Clear the message field so subsequent show() calls start with a fresh dialog
     final @NotNull EditText edtMessage =
         findViewById(R.id.sentry_dialog_user_feedback_edt_description);
     edtMessage.getText().clear();
@@ -332,14 +366,58 @@ protected void onStart() {
 
     final @NotNull SentryOptions options = Sentry.getCurrentScopes().getOptions();
     final @NotNull SentryFeedbackOptions feedbackOptions = options.getFeedbackOptions();
+    // Pause shake-to-report on this dialog's activity while it is visible, so a shake can't stack
+    // a second dialog on top of it
+    final @Nullable FeedbackShakeIntegration integration = getFeedbackShakeIntegration();
+    final @Nullable Activity activity = getActivity(getContext());
+    if (integration != null && activity != null) {
+      integration.onDialogVisible(activity, this);
+    }
     final @Nullable Runnable onFormOpen = feedbackOptions.getOnFormOpen();
     if (onFormOpen != null) {
-      onFormOpen.run();
+      try {
+        onFormOpen.run();
+      } catch (Exception e) {
+        options.getLogger().log(SentryLevel.ERROR, "onFormOpen callback threw an exception.", e);
+      }
     }
     options.getReplayController().captureReplay(false);
     currentReplayId = options.getReplayController().getReplayId();
   }
 
+  @Override
+  protected void onStop() {
+    super.onStop();
+    final @Nullable FeedbackShakeIntegration integration = getFeedbackShakeIntegration();
+    if (integration != null) {
+      integration.onDialogGone(this);
+    }
+  }
+
+  @Override
+  public void onDetachedFromWindow() {
+    super.onDetachedFromWindow();
+    // Runs on every teardown: on dismiss the decor view is removed before onStop(), and when the
+    // host activity is destroyed with the dialog still showing this is the only callback that
+    // fires. onDialogGone is idempotent, so reporting from both here and onStop() is safe.
+    final @Nullable FeedbackShakeIntegration integration = getFeedbackShakeIntegration();
+    if (integration != null) {
+      integration.onDialogGone(this);
+    }
+  }
+
+  /**
+   * The shake integration to report this dialog's visibility to, or null when shake-to-report isn't
+   * available (non-Android controller, or the integration was never installed).
+   */
+  private @Nullable FeedbackShakeIntegration getFeedbackShakeIntegration() {
+    final @NotNull SentryFeedbackOptions.IShakeController controller =
+        Sentry.getCurrentScopes().getOptions().getFeedbackOptions().getShakeController();
+    return controller instanceof FeedbackShakeIntegration
+        ? (FeedbackShakeIntegration) controller
+        : null;
+  }
+
   @Override
   public void show() {
     // If Sentry is disabled, don't show the dialog, but log a warning
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
index 170211abf55..f2118fb76de 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/FeedbackShakeIntegrationTest.kt
@@ -2,8 +2,16 @@ package io.sentry.android.core
 
 import android.app.Activity
 import android.app.Application
+import android.app.Dialog
 import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Handler
+import android.view.WindowManager
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
 import io.sentry.Scopes
 import io.sentry.SentryFeedbackOptions
 import io.sentry.test.DeferredExecutorService
@@ -12,10 +20,14 @@ import kotlin.test.BeforeTest
 import kotlin.test.Test
 import org.junit.runner.RunWith
 import org.mockito.kotlin.any
+import org.mockito.kotlin.argumentCaptor
 import org.mockito.kotlin.atLeastOnce
+import org.mockito.kotlin.doAnswer
 import org.mockito.kotlin.eq
+import org.mockito.kotlin.isA
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.never
+import org.mockito.kotlin.times
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.whenever
 
@@ -165,4 +177,316 @@ class FeedbackShakeIntegrationTest {
     val sut = fixture.getSut()
     sut.close()
   }
+
+  @Test
+  fun `register sets itself as shake controller even when useShakeGesture is disabled`() {
+    val sut = fixture.getSut(useShakeGesture = false)
+    sut.register(fixture.scopes, fixture.options)
+
+    assertThat(fixture.options.feedbackOptions.shakeController).isSameInstanceAs(sut)
+    assertThat(sut.isOnShakeEnabled).isFalse()
+  }
+
+  @Test
+  fun `enable after register starts shake detection at runtime`() {
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+    whenever(fixture.activity.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = false)
+    sut.register(fixture.scopes, fixture.options)
+    verify(fixture.application, never()).registerActivityLifecycleCallbacks(any())
+
+    sut.enableOnShake()
+
+    assertThat(sut.isOnShakeEnabled).isTrue()
+    verify(fixture.application).registerActivityLifecycleCallbacks(any())
+    // Hooks into the already-resumed activity
+    verify(fixture.activity).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `enable is idempotent`() {
+    val sut = fixture.getSut(useShakeGesture = false)
+    sut.register(fixture.scopes, fixture.options)
+
+    sut.enableOnShake()
+    sut.enableOnShake()
+
+    verify(fixture.application, times(1)).registerActivityLifecycleCallbacks(any())
+  }
+
+  @Test
+  fun `disable stops shake detection at runtime`() {
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    sut.disableOnShake()
+
+    assertThat(sut.isOnShakeEnabled).isFalse()
+    verify(fixture.application).unregisterActivityLifecycleCallbacks(any())
+  }
+
+  @Test
+  fun `disable is idempotent`() {
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    sut.disableOnShake()
+    sut.disableOnShake()
+
+    verify(fixture.application, times(1)).unregisterActivityLifecycleCallbacks(any())
+  }
+
+  @Test
+  fun `disable when never enabled does not unregister callbacks`() {
+    val sut = fixture.getSut(useShakeGesture = false)
+    sut.register(fixture.scopes, fixture.options)
+
+    sut.disableOnShake()
+
+    verify(fixture.application, never()).unregisterActivityLifecycleCallbacks(any())
+  }
+
+  @Test
+  fun `enable before register is a no-op`() {
+    val sut = fixture.getSut(useShakeGesture = false)
+
+    sut.enableOnShake()
+
+    assertThat(sut.isOnShakeEnabled).isFalse()
+    verify(fixture.application, never()).registerActivityLifecycleCallbacks(any())
+  }
+
+  @Test
+  fun `re-enable after disable re-arms shake detection`() {
+    val deferredExecutor = DeferredExecutorService()
+    fixture.options.executorService = deferredExecutor
+    whenever(fixture.application.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+    sut.disableOnShake()
+    sut.enableOnShake()
+
+    deferredExecutor.runAll()
+
+    assertThat(sut.isOnShakeEnabled).isTrue()
+    verify(fixture.application, atLeastOnce()).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `close disables shake detection`() {
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    sut.close()
+
+    assertThat(sut.isOnShakeEnabled).isFalse()
+  }
+
+  @Test
+  fun `a visible dialog does not tear down the detection machinery`() {
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    val dialog = mock<Dialog>()
+    sut.onDialogVisible(fixture.activity, dialog)
+    sut.onDialogGone(dialog)
+
+    verify(fixture.application, never()).unregisterActivityLifecycleCallbacks(any())
+    assertThat(sut.isOnShakeEnabled).isTrue()
+  }
+
+  @Test
+  fun `a dialog suppresses detection on the activity it belongs to`() {
+    whenever(fixture.activity.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    sut.onDialogVisible(fixture.activity, mock())
+    assertThat(sut.dialogActivity).isSameInstanceAs(fixture.activity)
+
+    // Coming back to the activity the dialog is on (e.g. screen off/on) must not re-arm detection,
+    // otherwise a shake would stack a second dialog on top of the visible one.
+    sut.onActivityResumed(fixture.activity)
+
+    verify(fixture.activity, never()).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `a dialog on a backgrounded activity does not suppress detection on the next one`() {
+    // A dialog lives in the window of the activity that created it, so once that activity is no
+    // longer resumed the dialog cannot be seen - it must not keep detection off on the activity
+    // now in front. Android's order is A.onPause() -> B.onResume(), so exercise exactly that.
+    val otherActivity = mock<Activity>()
+    whenever(fixture.activity.getSystemService(any())).thenReturn(null)
+    whenever(otherActivity.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+    sut.onActivityResumed(fixture.activity)
+    sut.onDialogVisible(fixture.activity, mock())
+
+    sut.onActivityPaused(fixture.activity)
+    sut.onActivityResumed(otherActivity)
+
+    verify(otherActivity).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `a dialog reports the activity it is showing on, not the current one`() {
+    // The dialog's host activity is what a stacked dialog would land on, so a mid-transition
+    // CurrentActivityHolder must not decide which activity detection is suppressed for.
+    val otherActivity = mock<Activity>()
+    whenever(fixture.activity.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    CurrentActivityHolder.getInstance().setActivity(otherActivity)
+    sut.onDialogVisible(fixture.activity, mock())
+
+    assertThat(sut.dialogActivity).isSameInstanceAs(fixture.activity)
+
+    sut.onActivityResumed(fixture.activity)
+
+    verify(fixture.activity, never()).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `dismissing a dialog re-arms detection on the current activity`() {
+    whenever(fixture.activity.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+    sut.onActivityResumed(fixture.activity)
+    val dialog = mock<Dialog>()
+    sut.onDialogVisible(fixture.activity, dialog)
+    sut.onDialogGone(dialog)
+
+    assertThat(sut.dialogActivity).isNull()
+    verify(fixture.activity, atLeastOnce()).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `dismissing one of two visible dialogs keeps detection suppressed`() {
+    // Two dialogs can be visible at once, e.g. when the app calls showForm() while a dialog is
+    // already up. The first one going away must not re-arm detection under the second.
+    whenever(fixture.activity.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+    sut.onActivityResumed(fixture.activity)
+    val first = mock<Dialog>()
+    val second = mock<Dialog>()
+    sut.onDialogVisible(fixture.activity, first)
+    sut.onDialogVisible(fixture.activity, second)
+
+    sut.onDialogGone(first)
+    assertThat(sut.dialogActivity).isSameInstanceAs(fixture.activity)
+    verify(fixture.activity, times(1)).getSystemService(eq(Context.SENSOR_SERVICE))
+
+    sut.onDialogGone(second)
+    assertThat(sut.dialogActivity).isNull()
+    verify(fixture.activity, times(2)).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `reporting the same dialog gone twice re-arms detection only once`() {
+    // A dismissed dialog reports back from both onStop() and onDetachedFromWindow().
+    whenever(fixture.activity.getSystemService(any())).thenReturn(null)
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+    sut.onActivityResumed(fixture.activity)
+    val dialog = mock<Dialog>()
+    sut.onDialogVisible(fixture.activity, dialog)
+    sut.onDialogGone(dialog)
+    sut.onDialogGone(dialog)
+
+    // Once for the resume, once for the single re-arm - the second report is a no-op.
+    verify(fixture.activity, times(2)).getSystemService(eq(Context.SENSOR_SERVICE))
+  }
+
+  @Test
+  fun `a dialog that fails to show does not leave detection suppressed`() {
+    // Dialog.show() runs onStart() - which reports the dialog as visible and stops detection -
+    // before the window is added, so an addView() failure hits with the dialog already tracked
+    // and no lifecycle callback left to report it gone.
+    val sensorManager = mock<SensorManager>()
+    val accelerometer = mock<Sensor>()
+    whenever(fixture.activity.getSystemService(Context.SENSOR_SERVICE)).thenReturn(sensorManager)
+    whenever(sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER, false))
+      .thenReturn(accelerometer)
+    whenever(fixture.activity.runOnUiThread(any())).thenAnswer {
+      (it.arguments[0] as Runnable).run()
+      null
+    }
+
+    val sut = fixture.getSut(useShakeGesture = true)
+    sut.register(fixture.scopes, fixture.options)
+    CurrentActivityHolder.getInstance().setActivity(fixture.activity)
+    sut.onActivityResumed(fixture.activity)
+
+    val dialog = mock<Dialog>()
+    doAnswer {
+        sut.onDialogVisible(fixture.activity, dialog)
+        throw WindowManager.BadTokenException("Unable to add window")
+      }
+      .whenever(dialog)
+      .show()
+    sut.setDialogFactory { dialog }
+
+    val listener = argumentCaptor<SensorEventListener>()
+    verify(sensorManager)
+      .registerListener(
+        listener.capture(),
+        eq(accelerometer),
+        eq(SensorManager.SENSOR_DELAY_NORMAL),
+        isA<Handler>(),
+      )
+    shake(listener.lastValue)
+
+    verify(dialog).show()
+    assertThat(sut.dialogActivity).isNull()
+    verify(sensorManager, times(2))
+      .registerListener(
+        any<SensorEventListener>(),
+        eq(accelerometer),
+        eq(SensorManager.SENSOR_DELAY_NORMAL),
+        isA<Handler>(),
+      )
+  }
+
+  private fun shake(listener: SensorEventListener) {
+    val baseTimestamp = 1_000_000_000L
+    val intervalNs = 20_000_000L
+    for (i in 0 until 20) {
+      listener.onSensorChanged(
+        createSensorEvent(floatArrayOf(20f, 0f, 0f), baseTimestamp + i * intervalNs)
+      )
+    }
+  }
+
+  private fun createSensorEvent(values: FloatArray, timestamp: Long): SensorEvent {
+    val sensor = mock<Sensor>()
+    whenever(sensor.type).thenReturn(Sensor.TYPE_ACCELEROMETER)
+
+    val constructor = SensorEvent::class.java.getDeclaredConstructor(Int::class.javaPrimitiveType)
+    constructor.isAccessible = true
+    val event = constructor.newInstance(values.size)
+    values.copyInto(event.values)
+    SensorEvent::class.java.getField("sensor").set(event, sensor)
+    SensorEvent::class.java.getField("timestamp").set(event, timestamp)
+    return event
+  }
 }
diff --git a/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt b/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt
index 9df2a16d72e..852b4e7e8f0 100644
--- a/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt
+++ b/sentry-android-core/src/test/java/io/sentry/android/core/SentryUserFeedbackFormTest.kt
@@ -1,6 +1,9 @@
 package io.sentry.android.core
 
+import android.app.Activity
+import android.app.Application
 import android.content.Context
+import android.os.Looper
 import android.view.WindowManager
 import android.widget.TextView
 import androidx.test.core.app.ApplicationProvider
@@ -19,13 +22,18 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
 import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
 import org.junit.runner.RunWith
 import org.mockito.Mockito.mockStatic
+import org.mockito.kotlin.any
 import org.mockito.kotlin.eq
 import org.mockito.kotlin.mock
 import org.mockito.kotlin.verify
 import org.mockito.kotlin.verifyNoInteractions
 import org.mockito.kotlin.whenever
+import org.robolectric.Robolectric
+import org.robolectric.Shadows.shadowOf
 
 @RunWith(AndroidJUnit4::class)
 class SentryUserFeedbackFormTest {
@@ -143,4 +151,66 @@ class SentryUserFeedbackFormTest {
     val flags = window.attributes.flags
     assertEquals(0, flags and WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM)
   }
+
+  @Test
+  fun `a crashing onFormClose callback does not crash the app when the dialog is closed`() {
+    fixture.options.isEnabled = true
+    fixture.options.feedbackOptions.onFormClose = Runnable { throw RuntimeException("user bug") }
+    val sut = fixture.getSut()
+    sut.show()
+
+    sut.dismiss()
+    // The dismiss listener is dispatched via a Handler message
+    shadowOf(Looper.getMainLooper()).idle()
+
+    verify(fixture.mockLogger)
+      .log(eq(SentryLevel.ERROR), eq("onFormClose callback threw an exception."), any())
+  }
+
+  @Test
+  fun `a crashing onFormClose callback still runs the user's dismiss listener`() {
+    fixture.options.isEnabled = true
+    fixture.options.feedbackOptions.onFormClose = Runnable { throw RuntimeException("user bug") }
+    val sut = fixture.getSut()
+    var dismissed = false
+    sut.setOnDismissListener { dismissed = true }
+    sut.show()
+
+    sut.dismiss()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertTrue(dismissed)
+  }
+
+  @Test
+  fun `a crashing onFormOpen callback does not crash the app when the dialog is shown`() {
+    fixture.options.isEnabled = true
+    fixture.options.feedbackOptions.onFormOpen = Runnable { throw RuntimeException("user bug") }
+    val sut = fixture.getSut()
+
+    sut.show()
+
+    verify(fixture.mockLogger)
+      .log(eq(SentryLevel.ERROR), eq("onFormOpen callback threw an exception."), any())
+    // The form open must still complete its own work after the callback crash
+    verify(fixture.mockReplayController).captureReplay(eq(false))
+  }
+
+  @Test
+  fun `dialog reports its own host activity to the shake integration while visible`() {
+    fixture.options.isEnabled = true
+    val integration = FeedbackShakeIntegration(fixture.application as Application)
+    fixture.options.feedbackOptions.setShakeController(integration)
+    val activity = Robolectric.buildActivity(Activity::class.java).setup().get()
+
+    val sut = SentryUserFeedbackForm(activity, 0, null, null, null)
+    sut.show()
+
+    assertEquals(activity, integration.dialogActivity)
+
+    sut.dismiss()
+    shadowOf(Looper.getMainLooper()).idle()
+
+    assertNull(integration.dialogActivity)
+  }
 }
diff --git a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
index 90e75feee71..b38f17ed64c 100644
--- a/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
+++ b/sentry-samples/sentry-samples-android/src/main/java/io/sentry/samples/android/MainActivity.kt
@@ -805,21 +805,23 @@ fun UserFeedbackScreen() {
       }
     }
 
-    // Enable shake-to-show for a specific form instance
+    // Toggle shake-to-show at runtime using the global Sentry.feedback() API
     item(span = { GridItemSpan(maxLineSpan) }) {
+      var shakeEnabled by remember { mutableStateOf(Sentry.feedback().isOnShakeEnabled) }
       Button(
         modifier = Modifier,
         onClick = {
-          SentryUserFeedbackForm.Builder(activity)
-            .configurator { options ->
-              options.isUseShakeGesture = true
-              options.formTitle = "Shake Feedback"
-            }
-            .create()
-          Toast.makeText(activity, "Shake your device to open the form!", Toast.LENGTH_SHORT).show()
+          if (shakeEnabled) {
+            Sentry.feedback().disableOnShake()
+          } else {
+            Sentry.feedback().enableOnShake()
+            Toast.makeText(activity, "Shake your device to open the form!", Toast.LENGTH_SHORT)
+              .show()
+          }
+          shakeEnabled = Sentry.feedback().isOnShakeEnabled
         },
       ) {
-        Text(text = "Enable Shake-to-Show")
+        Text(text = if (shakeEnabled) "Disable Shake-to-Show" else "Enable Shake-to-Show")
       }
     }
   }
diff --git a/sentry/api/sentry.api b/sentry/api/sentry.api
index 54729fdb12b..334b617fb7d 100644
--- a/sentry/api/sentry.api
+++ b/sentry/api/sentry.api
@@ -854,6 +854,9 @@ public abstract interface class io/sentry/IFeedbackApi {
 	public abstract fun capture (Lio/sentry/protocol/Feedback;)Lio/sentry/protocol/SentryId;
 	public abstract fun capture (Lio/sentry/protocol/Feedback;Lio/sentry/Hint;)Lio/sentry/protocol/SentryId;
 	public abstract fun capture (Lio/sentry/protocol/Feedback;Lio/sentry/Hint;Lio/sentry/ScopeCallback;)Lio/sentry/protocol/SentryId;
+	public abstract fun disableOnShake ()V
+	public abstract fun enableOnShake ()V
+	public abstract fun isOnShakeEnabled ()Z
 	public abstract fun show ()V
 	public abstract fun show (Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
 	public abstract fun show (Lio/sentry/protocol/SentryId;Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
@@ -1605,7 +1608,10 @@ public final class io/sentry/NoOpFeedbackApi : io/sentry/IFeedbackApi {
 	public fun capture (Lio/sentry/protocol/Feedback;)Lio/sentry/protocol/SentryId;
 	public fun capture (Lio/sentry/protocol/Feedback;Lio/sentry/Hint;)Lio/sentry/protocol/SentryId;
 	public fun capture (Lio/sentry/protocol/Feedback;Lio/sentry/Hint;Lio/sentry/ScopeCallback;)Lio/sentry/protocol/SentryId;
+	public fun disableOnShake ()V
+	public fun enableOnShake ()V
 	public static fun getInstance ()Lio/sentry/NoOpFeedbackApi;
+	public fun isOnShakeEnabled ()Z
 	public fun show ()V
 	public fun show (Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
 	public fun show (Lio/sentry/protocol/SentryId;Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
@@ -3236,6 +3242,7 @@ public final class io/sentry/SentryFeedbackOptions {
 	public fun getOnFormOpen ()Ljava/lang/Runnable;
 	public fun getOnSubmitError ()Lio/sentry/SentryFeedbackOptions$SentryFeedbackCallback;
 	public fun getOnSubmitSuccess ()Lio/sentry/SentryFeedbackOptions$SentryFeedbackCallback;
+	public fun getShakeController ()Lio/sentry/SentryFeedbackOptions$IShakeController;
 	public fun getSubmitButtonLabel ()Ljava/lang/CharSequence;
 	public fun getSuccessMessageText ()Ljava/lang/CharSequence;
 	public fun isEmailRequired ()Z
@@ -3261,6 +3268,7 @@ public final class io/sentry/SentryFeedbackOptions {
 	public fun setOnFormOpen (Ljava/lang/Runnable;)V
 	public fun setOnSubmitError (Lio/sentry/SentryFeedbackOptions$SentryFeedbackCallback;)V
 	public fun setOnSubmitSuccess (Lio/sentry/SentryFeedbackOptions$SentryFeedbackCallback;)V
+	public fun setShakeController (Lio/sentry/SentryFeedbackOptions$IShakeController;)V
 	public fun setShowBranding (Z)V
 	public fun setShowEmail (Z)V
 	public fun setShowName (Z)V
@@ -3275,6 +3283,12 @@ public abstract interface class io/sentry/SentryFeedbackOptions$IFormHandler {
 	public abstract fun showForm (Lio/sentry/protocol/SentryId;Lio/sentry/SentryFeedbackOptions$OptionsConfigurator;)V
 }
 
+public abstract interface class io/sentry/SentryFeedbackOptions$IShakeController {
+	public abstract fun disableOnShake ()V
+	public abstract fun enableOnShake ()V
+	public abstract fun isOnShakeEnabled ()Z
+}
+
 public abstract interface class io/sentry/SentryFeedbackOptions$OptionsConfigurator {
 	public abstract fun configure (Lio/sentry/SentryFeedbackOptions;)V
 }
diff --git a/sentry/src/main/java/io/sentry/FeedbackApi.java b/sentry/src/main/java/io/sentry/FeedbackApi.java
index b8b8a3c9b9a..3822c6fd7c7 100644
--- a/sentry/src/main/java/io/sentry/FeedbackApi.java
+++ b/sentry/src/main/java/io/sentry/FeedbackApi.java
@@ -31,6 +31,21 @@ public void show(
     options.getFeedbackOptions().getFormHandler().showForm(associatedEventId, configurator);
   }
 
+  @Override
+  public void enableOnShake() {
+    scopes.getOptions().getFeedbackOptions().getShakeController().enableOnShake();
+  }
+
+  @Override
+  public void disableOnShake() {
+    scopes.getOptions().getFeedbackOptions().getShakeController().disableOnShake();
+  }
+
+  @Override
+  public boolean isOnShakeEnabled() {
+    return scopes.getOptions().getFeedbackOptions().getShakeController().isOnShakeEnabled();
+  }
+
   @Override
   public @NotNull SentryId capture(final @NotNull Feedback feedback) {
     return scopes.captureFeedback(feedback);
diff --git a/sentry/src/main/java/io/sentry/IFeedbackApi.java b/sentry/src/main/java/io/sentry/IFeedbackApi.java
index 5bab630fa8b..b0915bc43c2 100644
--- a/sentry/src/main/java/io/sentry/IFeedbackApi.java
+++ b/sentry/src/main/java/io/sentry/IFeedbackApi.java
@@ -15,6 +15,33 @@ void show(
       final @Nullable SentryId associatedEventId,
       final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator);
 
+  /**
+   * Enables showing the feedback form when a shake gesture is detected, overriding {@link
+   * SentryFeedbackOptions#isUseShakeGesture()}. Only supported on Android; no-op on other
+   * platforms.
+   */
+  void enableOnShake();
+
+  /**
+   * Disables showing the feedback form when a shake gesture is detected, overriding {@link
+   * SentryFeedbackOptions#isUseShakeGesture()}. Only supported on Android; no-op on other
+   * platforms.
+   *
+   * <p>This turns off the SDK-wide shake detection only. A feedback form whose own options enable
+   * the shake gesture still runs its own detection while it is showing and while its host activity
+   * is alive, so shaking can re-open that form.
+   */
+  void disableOnShake();
+
+  /**
+   * Whether showing the feedback form on a shake gesture is currently enabled. Always {@code false}
+   * on non-Android platforms. Reflects the SDK-wide shake detection only; a form running its own
+   * shake detection is not covered by this.
+   *
+   * @return true if the feedback form is shown when a shake gesture is detected
+   */
+  boolean isOnShakeEnabled();
+
   @NotNull
   SentryId capture(final @NotNull Feedback feedback);
 
diff --git a/sentry/src/main/java/io/sentry/NoOpFeedbackApi.java b/sentry/src/main/java/io/sentry/NoOpFeedbackApi.java
index bdef5d37590..23ea5cb47eb 100644
--- a/sentry/src/main/java/io/sentry/NoOpFeedbackApi.java
+++ b/sentry/src/main/java/io/sentry/NoOpFeedbackApi.java
@@ -26,6 +26,17 @@ public void show(
       final @Nullable SentryId associatedEventId,
       final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator) {}
 
+  @Override
+  public void enableOnShake() {}
+
+  @Override
+  public void disableOnShake() {}
+
+  @Override
+  public boolean isOnShakeEnabled() {
+    return false;
+  }
+
   @Override
   public @NotNull SentryId capture(final @NotNull Feedback feedback) {
     return SentryId.EMPTY_ID;
diff --git a/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java b/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java
index a72b352317e..69b16b87ac1 100644
--- a/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryFeedbackOptions.java
@@ -93,8 +93,12 @@ public final class SentryFeedbackOptions {
 
   private @NotNull IFormHandler iFormHandler;
 
-  SentryFeedbackOptions(@NotNull IFormHandler iFormHandler) {
+  private @NotNull IShakeController shakeController;
+
+  SentryFeedbackOptions(
+      final @NotNull IFormHandler iFormHandler, final @NotNull IShakeController shakeController) {
     this.iFormHandler = iFormHandler;
+    this.shakeController = shakeController;
   }
 
   /** Creates a copy of the passed {@link SentryFeedbackOptions}. */
@@ -122,6 +126,7 @@ public SentryFeedbackOptions(final @NotNull SentryFeedbackOptions other) {
     this.onSubmitSuccess = other.onSubmitSuccess;
     this.onSubmitError = other.onSubmitError;
     this.iFormHandler = other.iFormHandler;
+    this.shakeController = other.shakeController;
   }
 
   /**
@@ -554,6 +559,26 @@ public void setFormHandler(final @NotNull IFormHandler iFormHandler) {
     return iFormHandler;
   }
 
+  /**
+   * Sets the controller to be used to enable/disable shake-to-report at runtime.
+   *
+   * @param shakeController the controller to be used to enable/disable shake-to-report at runtime
+   */
+  @ApiStatus.Internal
+  public void setShakeController(final @NotNull IShakeController shakeController) {
+    this.shakeController = shakeController;
+  }
+
+  /**
+   * Gets the controller to be used to enable/disable shake-to-report at runtime.
+   *
+   * @return the controller to be used to enable/disable shake-to-report at runtime
+   */
+  @ApiStatus.Internal
+  public @NotNull IShakeController getShakeController() {
+    return shakeController;
+  }
+
   @Override
   public String toString() {
     return "SentryFeedbackOptions{"
@@ -615,6 +640,16 @@ void showForm(
         final @Nullable SentryFeedbackOptions.OptionsConfigurator configurator);
   }
 
+  /** Controls shake-to-report at runtime, overriding {@link #isUseShakeGesture()}. */
+  @ApiStatus.Internal
+  public interface IShakeController {
+    void enableOnShake();
+
+    void disableOnShake();
+
+    boolean isOnShakeEnabled();
+  }
+
   /** Configuration callback for feedback options. */
   public interface OptionsConfigurator {
 
diff --git a/sentry/src/main/java/io/sentry/SentryOptions.java b/sentry/src/main/java/io/sentry/SentryOptions.java
index dc9d9521dbb..49b1d0deaf2 100644
--- a/sentry/src/main/java/io/sentry/SentryOptions.java
+++ b/sentry/src/main/java/io/sentry/SentryOptions.java
@@ -3538,7 +3538,23 @@ private SentryOptions(final boolean empty) {
     feedbackOptions =
         new SentryFeedbackOptions(
             (associatedEventId, configurator) ->
-                logger.log(SentryLevel.WARNING, "showForm() can only be called in Android."));
+                logger.log(SentryLevel.WARNING, "showForm() can only be called in Android."),
+            new SentryFeedbackOptions.IShakeController() {
+              @Override
+              public void enableOnShake() {
+                logger.log(SentryLevel.WARNING, "Shake to report is only supported on Android.");
+              }
+
+              @Override
+              public void disableOnShake() {
+                logger.log(SentryLevel.WARNING, "Shake to report is only supported on Android.");
+              }
+
+              @Override
+              public boolean isOnShakeEnabled() {
+                return false;
+              }
+            });
 
     if (!empty) {
       setSpanFactory(SpanFactoryFactory.create(new LoadClass(), NoOpLogger.getInstance()));
diff --git a/sentry/src/test/java/io/sentry/FeedbackApiTest.kt b/sentry/src/test/java/io/sentry/FeedbackApiTest.kt
new file mode 100644
index 00000000000..762e5241b4e
--- /dev/null
+++ b/sentry/src/test/java/io/sentry/FeedbackApiTest.kt
@@ -0,0 +1,47 @@
+package io.sentry
+
+import com.google.common.truth.Truth.assertThat
+import kotlin.test.Test
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class FeedbackApiTest {
+
+  private class Fixture {
+    val shakeController = mock<SentryFeedbackOptions.IShakeController>()
+    val options = SentryOptions().apply { feedbackOptions.setShakeController(shakeController) }
+    val scopes = mock<IScopes>().also { whenever(it.options).thenReturn(options) }
+
+    fun getSut(): FeedbackApi = FeedbackApi(scopes)
+  }
+
+  private val fixture = Fixture()
+
+  @Test
+  fun `enableOnShake delegates to the shake controller`() {
+    fixture.getSut().enableOnShake()
+
+    verify(fixture.shakeController).enableOnShake()
+  }
+
+  @Test
+  fun `disableOnShake delegates to the shake controller`() {
+    fixture.getSut().disableOnShake()
+
+    verify(fixture.shakeController).disableOnShake()
+  }
+
+  @Test
+  fun `isOnShakeEnabled delegates to the shake controller`() {
+    whenever(fixture.shakeController.isOnShakeEnabled).thenReturn(true)
+
+    assertThat(fixture.getSut().isOnShakeEnabled).isTrue()
+    verify(fixture.shakeController).isOnShakeEnabled
+  }
+
+  @Test
+  fun `default shake controller is disabled`() {
+    assertThat(SentryOptions().feedbackOptions.shakeController.isOnShakeEnabled).isFalse()
+  }
+}
diff --git a/sentry/src/test/java/io/sentry/SentryFeedbackOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryFeedbackOptionsTest.kt
index e4b96cb17d0..c3e0dbd7303 100644
--- a/sentry/src/test/java/io/sentry/SentryFeedbackOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryFeedbackOptionsTest.kt
@@ -1,6 +1,7 @@
 package io.sentry
 
 import io.sentry.SentryFeedbackOptions.IFormHandler
+import io.sentry.SentryFeedbackOptions.IShakeController
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import org.mockito.kotlin.mock
@@ -8,7 +9,7 @@ import org.mockito.kotlin.mock
 class SentryFeedbackOptionsTest {
   @Test
   fun `feedback options is initialized with default values`() {
-    val options = SentryFeedbackOptions(mock<IFormHandler>())
+    val options = SentryFeedbackOptions(mock<IFormHandler>(), mock<IShakeController>())
     assertEquals(false, options.isNameRequired)
     assertEquals(true, options.isShowName)
     assertEquals(false, options.isEmailRequired)
@@ -35,7 +36,7 @@ class SentryFeedbackOptionsTest {
   @Test
   fun `feedback options copy constructor`() {
     val options =
-      SentryFeedbackOptions(mock<IFormHandler>()).apply {
+      SentryFeedbackOptions(mock<IFormHandler>(), mock<IShakeController>()).apply {
         isNameRequired = true
         isShowName = false
         isEmailRequired = true
@@ -81,5 +82,6 @@ class SentryFeedbackOptionsTest {
     assertEquals(options.onSubmitSuccess, optionsCopy.onSubmitSuccess)
     assertEquals(options.onSubmitError, optionsCopy.onSubmitError)
     assertEquals(options.formHandler, optionsCopy.formHandler)
+    assertEquals(options.shakeController, optionsCopy.shakeController)
   }
 }
diff --git a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
index f1ee97459a1..64482b5d5d0 100644
--- a/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
+++ b/sentry/src/test/java/io/sentry/SentryOptionsTest.kt
@@ -947,6 +947,18 @@ class SentryOptionsTest {
     verify(logger).log(eq(SentryLevel.WARNING), eq("showForm() can only be called in Android."))
   }
 
+  @Test
+  fun `default shake controller logs a warning`() {
+    val logger = mock<ILogger>()
+    val options =
+      SentryOptions.empty().apply {
+        setLogger(logger)
+        isDebug = true
+      }
+    options.feedbackOptions.shakeController.enableOnShake()
+    verify(logger).log(eq(SentryLevel.WARNING), eq("Shake to report is only supported on Android."))
+  }
+
   @Test
   fun `autoTransactionDeadlineTimeoutMillis option defaults to 30000`() {
     val options = SentryOptions.empty()

From 4fb69affb1d8decfa787044cbacb7573a1b2e42b Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 14 Aug 2026 10:58:27 +0200
Subject: [PATCH 390/391] chore: update scripts/update-sentry-native-ndk.sh to
 0.16.3 (#5962)

Co-authored-by: GitHub <noreply@github.com>
---
 CHANGELOG.md              | 8 ++++++++
 gradle/libs.versions.toml | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 83df10a9871..0a45ec3fe37 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,13 @@
 # Changelog
 
+## Unreleased
+
+### Dependencies
+
+- Bump Native SDK from v0.16.2 to v0.16.3 ([#5962](https://github.com/getsentry/sentry-java/pull/5962))
+  - [changelog](https://github.com/getsentry/sentry-native/blob/master/CHANGELOG.md#0163)
+  - [diff](https://github.com/getsentry/sentry-native/compare/0.16.2...0.16.3)
+
 ## 8.53.0
 
 ### Features
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 0a47ab7e6c6..bb4d18c7a0e 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -169,7 +169,7 @@ quartz = { module = "org.quartz-scheduler:quartz", version = "2.3.0" }
 reactor-core = { module = "io.projectreactor:reactor-core", version = "3.5.3" }
 retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" }
 retrofit-gson = { module = "com.squareup.retrofit2:converter-gson", version.ref = "retrofit" }
-sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.16.2" }
+sentry-native-ndk = { module = "io.sentry:sentry-native-ndk", version = "0.16.3" }
 servlet-api = { module = "javax.servlet:javax.servlet-api", version = "3.1.0" }
 servlet-jakarta-api = { module = "jakarta.servlet:jakarta.servlet-api", version = "6.1.0" }
 slf4j-api = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }

From 79f1f2fa0cfc0eb55fb2648ff5d76791c365206e Mon Sep 17 00:00:00 2001
From: Nelson Osacky <nelson.osacky@sentry.io>
Date: Fri, 14 Aug 2026 13:39:41 +0200
Subject: [PATCH 391/391] docs(agents): Fold pr.mdc into the create-java-pr
 skill (#5936)

* docs(agents): Fold pr.mdc into the create-java-pr skill

The pr.mdc rule file and the create-java-pr skill described the same
six-step PR workflow, and both inlined a copy of the PR template and the
changelog subsection table. Nobody on the team uses Cursor, so the
rule/skill split earned nothing and the two copies had already drifted:
both inlined templates were missing the "Public API changes reviewed by
another Mobile SDK team member" checklist item that
.github/pull_request_template.md has gained since.

Delete pr.mdc and give its content one home each. The conventions the
skill was missing (allowed commit types, PR title format, changelog
rebase caveat) move into the skill. The stacked-PR workflow moves to a
references file the skill loads on demand, so the common standalone-PR
path no longer carries 150 lines that only apply to stacks.

The skill now reads .github/pull_request_template.md instead of
reproducing it, leaving one copy that cannot drift.

#skip-changelog

* docs(agents): Trim generic stacking guidance from stacked-prs.md

The reference file mixed two kinds of content: the standard Graphite-style
stacking workflow, which any agent can reconstruct from general knowledge and
`gh` usage, and the parts specific to this repo. The generic half diluted the
half that matters.

Drop the chain-walking recipe, the branch naming convention, the generic
create/merge/sync steps, and the restatement of the stack shape. Keep what is
not derivable: why the collection branch exists (`main` is squash-only, which
conflicts repeatedly when syncing a stack), the title and stack list formats,
and the permission-pattern constraint on editing PR bodies.

Collect the four destructive-operation warnings under one heading instead of
leaving them scattered across three sections, and point SKILL.md at the
surviving section names.

#skip-changelog

* docs(agents): Fix defects found by dry-running the PR skill

Ran fresh agents through "create a PR" and "create a stacked PR" against
the deduped docs, stopping each before the first mutating action. Both
paths loaded the intended files, but four defects surfaced:

- SKILL.md named stacked-prs.md the source of truth for branch naming,
  which that file never covered. Corrected to title naming; the branch
  rule stays in Step 1, where the branch is created.
- Four passages referenced the collection branch PR, but no step ever
  opened it. Added next to the branch creation, with its title and
  merge-reminder exceptions.
- The PR-description editing rule was stated three times and had already
  drifted. It now lives once in SKILL.md, which both the standalone and
  stacked paths read, and stacked-prs.md points back to it.
- AGENTS.md rule 7 told agents to propose but not execute a commit while
  the create-java-pr skill commits, pushes, and opens the PR, leaving two
  terminal states for one request. Scoped rule 7 to implementation work.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
---
 .claude/skills/create-java-pr/SKILL.md        |  76 ++---
 .../create-java-pr/references/stacked-prs.md  |  86 ++++++
 .cursor/rules/pr.mdc                          | 264 ------------------
 AGENTS.md                                     |   7 +-
 4 files changed, 128 insertions(+), 305 deletions(-)
 create mode 100644 .claude/skills/create-java-pr/references/stacked-prs.md
 delete mode 100644 .cursor/rules/pr.mdc

diff --git a/.claude/skills/create-java-pr/SKILL.md b/.claude/skills/create-java-pr/SKILL.md
index e2a9b9bc785..17b5839d88a 100644
--- a/.claude/skills/create-java-pr/SKILL.md
+++ b/.claude/skills/create-java-pr/SKILL.md
@@ -7,7 +7,8 @@ description: Create a pull request in sentry-java. Use when asked to "create pr"
 
 Prepare local changes and create a pull request for the sentry-java repo.
 
-**Required reading:** Before proceeding, read `.cursor/rules/pr.mdc` for the full PR and stacked PR workflow details. That file is the source of truth for PR conventions, stack comment format, branch naming, and merge strategy.
+**For stacked PRs:** read `references/stacked-prs.md` before proceeding. It is the source of truth for
+stack structure, title naming, stack list format, and merge strategy.
 
 ## Step 0: Determine PR Type From Git Branch Context
 
@@ -66,7 +67,7 @@ git checkout -b <type>/<short-description>
 
 Derive the branch name from the changes being made. Use `feat/`, `fix/`, `ref/`, etc. matching the commit type conventions.
 
-**For stacked PRs:** For the first PR in a new stack, first create and push the collection branch (see `.cursor/rules/pr.mdc` § "Creating the Collection Branch"), then branch the PR off it. For subsequent PRs, branch off the previous stack branch. Use the naming conventions from `.cursor/rules/pr.mdc` § "Branch Naming".
+**For stacked PRs:** For the first PR in a new stack, first create and push the collection branch (see `references/stacked-prs.md` § "Why a Collection Branch"), then branch the PR off it. For subsequent PRs, branch off the previous stack branch. Give every branch in the stack a shared prefix naming the feature, with a descriptive suffix per PR.
 
 **CRITICAL: Never merge, fast-forward, or push commits into the collection branch.** It stays at its initial position until the user merges stack PRs through GitHub. Updating it will auto-merge and destroy the entire PR stack.
 
@@ -88,7 +89,13 @@ Check for uncommitted changes:
 git status --porcelain
 ```
 
-If there are uncommitted changes, invoke the `sentry-skills:commit` skill to stage and commit them following Sentry conventions.
+If there are uncommitted changes, invoke the `sentry-skills:commit` skill to stage and commit them following [Sentry commit message conventions](https://develop.sentry.dev/engineering-practices/commit-messages/):
+
+```
+<type>(<scope>): <subject>
+```
+
+Allowed types: `feat`, `fix`, `ref`, `chore`, `docs`, `test`, `perf`, `build`, `ci`, `style`, `meta`, `license`
 
 **Important:** When staging, ignore changes that are only relevant for local testing and should not be part of the PR. Common examples:
 
@@ -114,39 +121,28 @@ If the push fails due to diverged history, ask the user how to proceed rather th
 
 ## Step 5: Create PR
 
-Invoke the `sentry-skills:create-pr` skill to create a draft PR. When providing the PR body, use the repo's PR template structure from `.github/pull_request_template.md`:
+Invoke the `sentry-skills:create-pr` skill to create a draft PR.
+
+Read `.github/pull_request_template.md` and use it as the PR body structure — it is the single source
+of truth for the sections and checklist, so never reproduce it from memory. Fill in each section based
+on the changes being PR'd, drop the HTML comment hints, and check any checklist items that apply.
+
+**PR title format** — same as the commit subject (Step 3):
 
 ```
-## :scroll: Description
-<Describe the changes in detail>
-
-## :bulb: Motivation and Context
-<Why is this change required? What problem does it solve?>
-
-## :green_heart: How did you test it?
-<Describe how you tested>
-
-## :pencil: Checklist
-- [ ] I added GH Issue ID _&_ Linear ID
-- [ ] I added tests to verify the changes.
-- [ ] No new PII added or SDK only sends newly added PII if `sendDefaultPII` is enabled.
-- [ ] I updated the docs if needed.
-- [ ] I updated the wizard if needed.
-- [ ] Review from the native team if needed.
-- [ ] No breaking change or entry added to the changelog.
-- [ ] No breaking change for hybrid SDKs or communicated to hybrid SDKs.
-
-## :crystal_ball: Next steps
+<type>(<scope>): <Subject>
 ```
 
-Fill in each section based on the changes being PR'd. Check any checklist items that apply.
+Examples:
+- `feat(core): Add structured logging support`
+- `fix(android): Prevent crash on API 21 when registering receiver`
 
 **For stacked PRs:**
 
 - Pass `--base <previous-stack-branch>` so the PR targets the previous branch (first PR in a stack targets the collection branch).
-- Use the stacked PR title format: `<type>(<scope>): [<Topic> <N>] <Subject>` (see `.cursor/rules/pr.mdc` § "PR Title Naming").
-- Include the stack list at the top of the PR body, before the `## :scroll: Description` section (see `.cursor/rules/pr.mdc` § "Stack List in PR Description" for the format).
-- Add a merge method reminder at the very end of the PR body (see `.cursor/rules/pr.mdc` § "Stack List in PR Description" for the exact text). This only applies to stack PRs, not the collection branch PR.
+- Use the stacked PR title format: `<type>(<scope>): [<Topic> <N>] <Subject>` (see `references/stacked-prs.md` § "PR Title Naming").
+- Include the stack list at the top of the PR body, before the `## :scroll: Description` section (see `references/stacked-prs.md` § "Stack List in PR Description" for the format).
+- Add a merge method reminder at the very end of the PR body (see `references/stacked-prs.md` § "Stack List in PR Description" for the exact text). This only applies to stack PRs, not the collection branch PR.
 
 Then continue to Step 5.5 (stacked PRs only) or Step 6.
 
@@ -154,13 +150,9 @@ Then continue to Step 5.5 (stacked PRs only) or Step 6.
 
 Skip this step for standalone PRs.
 
-After creating the PR, update the PR description on **every other PR in the stack — including the collection branch PR** — so all PRs have the same up-to-date stack list. Follow the format and commands in `.cursor/rules/pr.mdc` § "Stack List in PR Description".
+After creating the PR, update the PR description on **every other PR in the stack — including the collection branch PR** — so all PRs have the same up-to-date stack list. Follow the format and commands in `references/stacked-prs.md` § "Stack List in PR Description".
 
-**Important:** When updating PR bodies, never use shell redirects (`>`, `>>`) or pipes (`|`) or compound commands (`&&`). These create compound shell expressions that won't match permission patterns. Instead:
-- Use `gh pr view <NUMBER> --json body --jq '.body'` to get the body (output returned directly)
-- Use the `Write` tool to save it to a temp file
-- Use the `Edit` tool to modify the temp file
-- Use `gh pr edit <NUMBER> --body-file /tmp/pr-body.md` to update
+Edit each body using the procedure in § "Editing PR Descriptions" below.
 
 ## Step 6: Update Changelog
 
@@ -190,6 +182,8 @@ Add an entry to `CHANGELOG.md` under the `## Unreleased` section.
 
 Create the subsection under `## Unreleased` if it does not already exist.
 
+**When rebasing:** A rebase onto `main` can land your branch after a release was cut, where the `## Unreleased` heading your entry lived under has since been renamed to that version number. If that happens, move your new entry into an `## Unreleased` section at the top of `CHANGELOG.md` (create the section if it no longer exists) so it is not left under an already-released version.
+
 #### Entry format
 
 ```markdown
@@ -210,8 +204,14 @@ git push
 
 ### No changelog needed
 
-If no changelog entry is needed, add `#skip-changelog` to the PR description to disable the changelog CI check:
+If no changelog entry is needed, append `#skip-changelog` to the end of the PR description to disable
+the changelog CI check, using the procedure in § "Editing PR Descriptions" below.
+
+## Editing PR Descriptions
+
+Do not use shell redirects (`>`, `>>`), pipes (`|`), or compound commands (`&&`, `||`). These create
+compound shell expressions that won't match permission patterns. Instead:
 
-1. Get the current body: `gh pr view <PR_NUMBER> --json body --jq '.body'`
-2. Use the `Write` tool to save the output to `/tmp/pr-body.md`, appending `\n#skip-changelog\n` at the end
-3. Update: `gh pr edit <PR_NUMBER> --body-file /tmp/pr-body.md`
+1. Read the body with `gh pr view <PR_NUMBER> --json body --jq '.body'` (output is returned directly)
+2. Use the `Write` tool to save it to `/tmp/pr-body.md`, and the `Edit` tool to modify it
+3. Update with `gh pr edit <PR_NUMBER> --body-file /tmp/pr-body.md`
diff --git a/.claude/skills/create-java-pr/references/stacked-prs.md b/.claude/skills/create-java-pr/references/stacked-prs.md
new file mode 100644
index 00000000000..56221fe4912
--- /dev/null
+++ b/.claude/skills/create-java-pr/references/stacked-prs.md
@@ -0,0 +1,86 @@
+# Stacked PRs
+
+Stacked PRs split a large feature into small, easy-to-review PRs where each builds on the previous
+one. The general mechanics are the standard [Graphite](https://graphite.dev/) stacking workflow —
+this file covers only what is specific to sentry-java.
+
+## Why a Collection Branch
+
+```
+main ← collection-branch ← stack-pr-1 ← stack-pr-2 ← stack-pr-3 ← ...
+```
+
+A **collection branch** is created from `main` and targets `main`. The first stack PR targets it
+rather than `main`, and each later PR targets the previous stack PR's branch.
+
+It exists because PRs targeting `main` are **squash**-merged, which causes repeated merge conflicts
+when syncing a stack. Stack PRs are therefore **merge-committed** into the collection branch, and
+only the collection branch is squash-merged into `main` at the end — giving `main` one clean commit
+for the whole feature.
+
+Create it with an empty commit, so GitHub allows opening a PR:
+
+```bash
+git commit --allow-empty -m "collection: <topic>"
+```
+
+Push it and open its PR against `main` right away — it is the PR the whole stack is eventually
+squash-merged through, and it carries the stack list like every other PR. Give it a plain title
+(`<type>(<scope>): <Topic>`, no `[<Topic> <N>]` bracket) and no merge method reminder.
+
+## Rules That Will Destroy a Stack If Broken
+
+**Never update the collection branch yourself.** Never merge, fast-forward, or push stack branch
+commits into it. It stays at its initial position (the empty commit on `main`) until the user merges
+stack PRs through GitHub one by one. Fast-forwarding it makes GitHub auto-merge and delete every
+stack PR branch, destroying the entire stack.
+
+**Never amend or force-push a stack branch.** No `git commit --amend`, `--force`, or
+`--force-with-lease` on a branch that is part of a stack — a force-push can cause GitHub to
+auto-merge or auto-close the other PRs in the stack. If a commit needs fixing, add a fixup commit.
+
+**Sync only between adjacent stack branches**, by merging forward — never into the collection branch.
+Prefer merge over rebase; only rebase if explicitly requested.
+
+**Do not merge PRs.** Only the user merges them, bottom to top.
+
+## PR Title Naming
+
+Include the topic name and a sequential number in brackets:
+
+```
+<type>(<scope>): [<Topic> <N>] <Subject>
+```
+
+Examples:
+- `feat(core): [Global Attributes 1] Add scope-level attributes API`
+- `feat(core): [Global Attributes 2] Wire scope attributes into LoggerApi and MetricsApi`
+
+## Stack List in PR Description
+
+Every PR in the stack — **including the collection branch PR** — must have a stack list **at the top
+of its description**, before the `## :scroll: Description` section. When a PR is added, update the
+description on **all** PRs in the stack. The stack list is also how you enumerate a stack: read it
+off any PR body rather than guessing from branch names, which may use different prefixes.
+
+```markdown
+## PR Stack (<Topic>)
+
+- #5118
+- #5120
+- #5121
+
+---
+```
+
+No status column — GitHub already shows that. The `---` separates the stack list from the rest of
+the description.
+
+**Merge method reminder:** on stack PRs (not the collection branch PR), end the description with:
+
+```markdown
+> ⚠️ **Merge this PR using a merge commit** (not squash). Only the collection branch is squash-merged into main.
+```
+
+Updating every PR's stack list means editing several descriptions — follow the procedure in
+`SKILL.md` § "Editing PR Descriptions".
diff --git a/.cursor/rules/pr.mdc b/.cursor/rules/pr.mdc
deleted file mode 100644
index 3a37ecc15f8..00000000000
--- a/.cursor/rules/pr.mdc
+++ /dev/null
@@ -1,264 +0,0 @@
----
-alwaysApply: false
-description: Pull request creation, stacked PRs, and PR workflow
----
-
-# Pull Request Rules
-
-## Creating a Pull Request
-
-### Step 1: Ensure Feature Branch
-
-If on `main`, create and switch to a new branch:
-
-```bash
-git checkout -b <type>/<short-description>
-```
-
-Branch names use `feat/`, `fix/`, `ref/`, etc. matching the commit type.
-
-### Step 2: Format Code and Regenerate API Files
-
-```bash
-./gradlew spotlessApply apiDump
-```
-
-This is **required** before every PR. Fix any failures before continuing.
-
-### Step 3: Commit Changes
-
-Use `git status --porcelain` to review changes. Ignore files only relevant for local testing (hardcoded debug toggles, sample app config, `.env` files). Restore those with `git checkout -- <file>`.
-
-Follow [Sentry commit message conventions](https://develop.sentry.dev/engineering-practices/commit-messages/):
-
-```
-<type>(<scope>): <subject>
-```
-
-Allowed types: `feat`, `fix`, `ref`, `chore`, `docs`, `test`, `perf`, `build`, `ci`, `style`, `meta`, `license`
-
-- Use imperative present tense ("add" not "added")
-- Capitalize subject, no trailing period
-- Keep under 100 characters
-
-### Step 4: Push
-
-```bash
-git push -u origin HEAD
-```
-
-If push fails due to diverged history, ask the user — do not force-push.
-
-### Step 5: Create PR
-
-Create a draft PR using the repo's PR template:
-
-```markdown
-## :scroll: Description
-<Describe the changes in detail>
-
-## :bulb: Motivation and Context
-<Why is this change required? What problem does it solve?>
-
-## :green_heart: How did you test it?
-<Describe how you tested>
-
-## :pencil: Checklist
-- [ ] I added GH Issue ID _&_ Linear ID
-- [ ] I added tests to verify the changes.
-- [ ] No new PII added or SDK only sends newly added PII if `sendDefaultPII` is enabled.
-- [ ] I updated the docs if needed.
-- [ ] I updated the wizard if needed.
-- [ ] Review from the native team if needed.
-- [ ] No breaking change or entry added to the changelog.
-- [ ] No breaking change for hybrid SDKs or communicated to hybrid SDKs.
-
-## :crystal_ball: Next steps
-```
-
-### Step 6: Update Changelog
-
-Add an entry to `CHANGELOG.md` under `## Unreleased` in the appropriate subsection:
-
-| Change Type | Subsection |
-|---|---|
-| New feature | `### Features` |
-| Bug fix | `### Fixes` |
-| Refactoring, internal cleanup | `### Internal` |
-| Dependency update | `### Dependencies` |
-
-Entry format:
-
-```markdown
-- <Short description> ([#<PR_NUMBER>](https://github.com/getsentry/sentry-java/pull/<PR_NUMBER>))
-```
-
-**When rebasing:** A rebase onto `main` can land your branch after a release was cut, where the `## Unreleased` heading your entry lived under has since been renamed to that version number. If that happens, move your new entry into an `## Unreleased` section at the top of `CHANGELOG.md` (create the section if it no longer exists) so it is not left under an already-released version.
-
-Commit changelog separately:
-
-```bash
-git add CHANGELOG.md && git commit -m "changelog" && git push
-```
-
-### PR Title Format
-
-Follow the commit message format:
-
-```
-<type>(<scope>): <Subject>
-```
-
-Examples:
-- `feat(core): Add structured logging support`
-- `fix(android): Prevent crash on API 21 when registering receiver`
-
----
-
-## Stacked PRs
-
-Stacked PRs split a large feature into small, easy-to-review PRs where each builds on the previous one. This follows the same concept as the [Graphite](https://graphite.dev/) stacking workflow.
-
-### Structure
-
-```
-main ← collection-branch ← stack-pr-1 ← stack-pr-2 ← stack-pr-3 ← ...
-```
-
-- A **collection branch** is created from `main` and targets `main`. It serves as the base for the entire stack.
-- The first PR in the stack targets the collection branch (not `main`).
-- Each subsequent PR targets the previous stack PR's branch as its base.
-- Each PR contains only incremental changes on top of the previous one.
-
-The collection branch exists so that individual stack PRs can be **merge-committed** (not squashed). PRs targeting `main` use squash merging, but that causes repeated merge conflicts when syncing the stack. Merge commits on non-`main` branches avoid this. The collection branch itself is squash-merged into `main` at the end.
-
-### Branch Naming
-
-Prefer a shared prefix for the feature, with descriptive suffixes per PR. The collection branch uses the shared prefix. The type prefix (`feat/`, `fix/`, etc.) may vary depending on the nature of each PR's changes:
-
-```
-feat/scope-attributes              # collection branch → targets main
-feat/scope-attributes-api          # PR 1 → targets collection branch
-feat/scope-attributes-logger       # PR 2 → targets PR 1
-fix/attribute-type-detection        # PR 3 (fix, different name — that's fine) → targets PR 2
-```
-
-### PR Title Naming
-
-Include the topic name and a sequential number in brackets:
-
-```
-<type>(<scope>): [<Topic> <N>] <Subject>
-```
-
-Examples:
-- `feat(core): [Global Attributes 1] Add scope-level attributes API`
-- `feat(core): [Global Attributes 2] Wire scope attributes into LoggerApi and MetricsApi`
-- `feat(samples): [Global Attributes 3] Showcase scope attributes in Spring Boot 4 sample`
-
-### Finding All PRs in a Stack
-
-Do **not** rely on branch name patterns — later PRs in a stack may use different prefixes or naming. Instead:
-
-1. Find the PR for the current branch:
-   ```bash
-   gh pr list --head "$(git branch --show-current)" --json number,title,baseRefName --jq '.[0]'
-   ```
-2. Read the PR description — the stack list is at the top of the body.
-3. If there is no stack list yet, walk the chain in both directions:
-   ```bash
-   # Find the PR whose head branch is the current PR's base (go up)
-   gh pr list --head <baseRefName> --json number,title,baseRefName
-
-   # Find PRs whose base branch is the current PR's head (go down)
-   gh pr list --base <currentBranch> --json number,title,headRefName
-   ```
-   Repeat until you reach the collection branch going up and find no more PRs going down.
-
-### Creating the Collection Branch
-
-Before the first stacked PR, create the collection branch with an empty commit (so GitHub allows opening a PR) and create the collection PR:
-
-```bash
-git checkout main
-git checkout -b feat/<topic>
-git commit --allow-empty -m "collection: <topic>"
-git push -u origin HEAD
-gh pr create --base main --draft --title "<type>(<scope>): <Topic>" --body "Collection PR for the <Topic> stack. Squash-merge this once all stack PRs are merged."
-```
-
-**CRITICAL: Do NOT manually update the collection branch.** Never merge, fast-forward, or push stack branch commits into the collection branch. The collection branch stays at its initial position (the empty commit on `main`) until the user merges individual stack PRs into it one by one through GitHub. If you fast-forward the collection branch to include stack commits, GitHub will auto-merge and delete all stack PR branches, destroying the entire stack.
-
-### Creating a New Stacked PR
-
-1. Start from the tip of the previous stack branch (or the collection branch for the first PR).
-2. Create a new branch, make changes, format, commit, and push.
-3. Create the PR with `--base <previous-branch>` (the collection branch for the first PR):
-   ```bash
-   gh pr create --base feat/previous-branch --draft --title "<type>(<scope>): [<Topic> <N>] <Subject>" --body "..."
-   ```
-4. Add the stack list to the top of the new PR's description and update it on all existing PRs in the stack (see below).
-
-### Stack List in PR Description
-
-Every PR in the stack — **including the collection branch PR** — must have a stack list **at the top of its description** (before the `## :scroll: Description` section). When a new PR is added, update the description on **all** PRs in the stack and on the collection branch PR.
-
-Format:
-
-```markdown
-## PR Stack (<Topic>)
-
-- #5118
-- #5120
-- #5121
-
----
-```
-
-No status column — GitHub already shows that. The `---` separates the stack list from the rest of the PR description.
-
-**Merge method reminder:** On stack PRs (not the collection branch PR), add the following line at the very end of the PR description:
-
-```markdown
-> ⚠️ **Merge this PR using a merge commit** (not squash). Only the collection branch is squash-merged into main.
-```
-
-This does not apply to standalone PRs or the collection branch PR.
-
-To update the PR description, use `--body-file` to avoid shell quoting issues with special characters in the body.
-
-**Important:** Do not use shell redirects (`>`, `>>`, `|`) or compound commands (`&&`, `||`). These create compound shell expressions that won't match permission patterns. Instead, use the `Write` and `Edit` tools for file manipulation:
-
-1. Read the current body with `gh pr view <PR_NUMBER> --json body --jq '.body'` (the output is returned directly — use the `Write` tool to save it to `/tmp/pr-body.md`)
-2. Use the `Edit` tool to prepend or replace the stack list section in `/tmp/pr-body.md`
-3. Update the description: `gh pr edit <PR_NUMBER> --body-file /tmp/pr-body.md`
-
-### Merging Stacked PRs (done by the user, not the agent)
-
-Individual stack PRs are merged in order from bottom to top (PR 1 first, then PR 2, etc.) using **merge commits** (not squash). After each merge, the next PR's base automatically becomes the merged branch's target. GitHub handles rebasing onto the new base.
-
-Once all stack PRs are merged into the collection branch, the collection PR is **squash-merged** into `main`. This gives `main` a clean single commit for the entire feature.
-
-**Do not merge PRs.** Only the user merges PRs.
-
-### Syncing the Stack
-
-When a base PR changes (e.g. after addressing review feedback on PR 1), merge the changes forward through the stack **between adjacent stack PR branches only**:
-
-```bash
-# On the branch for PR 2
-git checkout feat/scope-attributes-logger
-git merge feat/scope-attributes-api
-git push
-
-# On the branch for PR 3
-git checkout feat/scope-attributes-sample
-git merge feat/scope-attributes-logger
-git push
-```
-
-**Never merge into the collection branch.** Syncing only happens between stack PR branches. The collection branch is untouched until the user merges PRs through GitHub.
-
-Prefer merge over rebase — it preserves commit history, doesn't invalidate existing review comments, and avoids the need for force-pushing. Only rebase if explicitly requested.
-
-**Never amend or force-push stack branches.** Do not use `git commit --amend`, `--force`, or `--force-with-lease` on branches that are part of a stack. Amending a pushed commit requires a force-push, which can cause GitHub to auto-merge or auto-close other PRs in the stack. If a commit needs fixing, add a new fixup commit instead.
diff --git a/AGENTS.md b/AGENTS.md
index fd1fced0df6..42bc6677d17 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -20,7 +20,6 @@ rule file in `.cursor/rules/`:
 | `continuous_profiling_jvm` | `sentry-async-profiler`, `IContinuousProfiler`, `ProfileChunk`, JFR files, `ProfileLifecycle` |
 | `opentelemetry` | `sentry-opentelemetry-*`, agent vs agentless, span processing, sampling, context propagation |
 | `new_module` | Adding a new integration or sample module |
-| `pr` | Creating pull requests, stacked PRs, changelog entries |
 | `e2e_tests` | System tests, sample applications, `system-test-runner.py`, mock Sentry server |
 
 Rules can be combined — a tracing scope issue may need both `scopes` and `opentelemetry`.
@@ -99,7 +98,7 @@ make systemTest
 4. **High-level communication**: Give high-level explanations of changes made, not step-by-step descriptions
 5. **Simplicity first**: Make every task and code change as simple as possible. Avoid massive or complex changes. Impact as little code as possible.
 6. **Format and regenerate**: Once done, format code and regenerate .api files: `./gradlew spotlessApply apiDump`
-7. **Propose commit**: As final step, git stage relevant files and propose (but not execute) a single git commit command
+7. **Propose commit**: As final step, git stage relevant files and propose (but not execute) a single git commit command. This applies to implementation work; when the task is to open a PR, the `create-java-pr` skill takes over from here and does commit, push, and open it.
 
 ## Repository Skills
 
@@ -225,7 +224,9 @@ gh pr view --json url -q '.url'
 
 ### Changelog
 
-User-facing changes get an entry under the `## Unreleased` section of `CHANGELOG.md`. When rebasing onto `main`, a release may have renamed the `## Unreleased` heading your entry was under to a version number — if so, move your entry back into an `## Unreleased` section at the top of the file (create it if it no longer exists). See `.cursor/rules/pr.mdc` for the full changelog and PR workflow.
+User-facing changes get an entry under the `## Unreleased` section of `CHANGELOG.md`. The
+`create-java-pr` skill is the source of truth for the full changelog and PR workflow, including
+subsection selection and the rebase caveat when a release renames `## Unreleased`.
 
 ## Useful Resources